Laboratório 06
Checklist — SSD1306, MQTT nos dois sentidos e dashboard
- Stack Docker do curso rodando (T1, sem pontos)
-
platformio.inicom Adafruit SSD1306 + GFX;diagram.jsoncom o OLED em SDA 21 / SCL 22 (T2) - Tela local desenhada só quando muda (
telaSuja), fora do callback do temporizador (T3) - Intervalo alterado por MQTT (
.../cmd/intervalo, 2–60 s) e tela espelhada em texto em.../oled(T4) - Dashboard mínimo no Node-RED: réplica do OLED em texto, status e slider do intervalo (T5)
- Framebuffer do SSD1306 em
.../oled/fbdesenhado pixel a pixel no dashboard (T6) - Previsões P1–P3 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 0 · T2 10 · T3 20 · T4 25 · T5 20 · T6 25.
O autograder normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.
Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):
Verificação rápida das versões instaladas:
git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version
Verificação rápida de autenticação e alias:
git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"
Adicionar o comando git conferir:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Configuração do ambiente de desenvolvimento
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
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, um dashboard mínimo mostra a tela do OLED de duas formas:
como texto e pixel a pixel, a partir do framebuffer. Gravar as leituras num banco
(SQLite) fica para o Lab 08.
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.
- 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), com o mínimo de nós.
Material
- VS Code + PlatformIO + extensão Wokwi (ESP32 simulado, sem placa física).
- Stack Docker do curso: nesta aula usamos o Node-RED com o Dashboard 2.0
(
@flowfuse/node-red-dashboard), já instalado 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/ELT73A-S22-2026-2/lab06-grupo-a
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-a/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-b
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-b/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-c
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-c/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-d
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-d/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-e
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-e/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-f
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-f/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-g
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-g/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-h
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-h/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-i
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-i/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-j
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-j/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-k
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-k/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-l
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-l/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-m
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-m/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-x
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-x/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-p
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-p/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\lab06-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT73A-S22-2026-2/lab06-grupo-n
- Commits: https://github.com/ELT73A-S22-2026-2/lab06-grupo-n/commits/main/
- Acessos: ACESSO-LAB06.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/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%\ELT73AS22\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.
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\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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%\ELT73AS22\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 elt73a --lab lab06 --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 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.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Docker Operacional · 0 pts
- T2 — Circuito e dependencias do SSD1306 · 10 pts
- T3 — Tela local no OLED · 20 pts
- T4 — MQTT nos dois sentidos · 25 pts
- T5 — Node-RED: replica do OLED e comando do intervalo · 20 pts
- T6 — Framebuffer pixel a pixel no dashboard · 25 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
- ├── 📄t3-serial.txt👈 Criar Aqui
- ├── 📄t3-oled.png👈 Criar Aqui
- ├── 📄t4-mqtt.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 elt73a/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", ...]} (T4) |
.../oled/fb | ESP32 → broker | 1024 bytes do framebuffer em base64 (T6) |
.../cmd/intervalo | broker → ESP32 | 10 (segundos, 2–60) |
Parte 0 — Docker Operacional
Precisa do Docker Desktop aberto (com pelo menos 4 GB de memória) e do Python 3. Os comandos são para o Prompt de Comando (cmd) do Windows.
docker desktop start
Disciplina: ELT73A - Sistemas Microcontrolados (--disciplina elt73a).
Configuração do lab06: --sem-gitea--sem-microbin--sem-fuxa--sem-ntfy--captura--docs
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- Conta:
lab06-a(usuário, tópicos MQTTlab06-a/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-a\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-a\docker\lab06-a
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-a/
- Dashboard: http://localhost/lab06-a/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-a-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-a-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-a\data\lab06-a. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && rmdir /s /q "data\lab06-a" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-a-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && (rmdir /s /q "data\lab06-a\node_modules" 2>nul & del /q "data\lab06-a\package.json" "data\lab06-a\package-lock.json" "data\lab06-a\.config.nodes.json" 2>nul & docker compose start lab06-a-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-a desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && git checkout -- "data\lab06-a" && git clean -fdq "data\lab06-a" && docker compose start lab06-a-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && tar -a -cf nodered-limpo.zip "data\lab06-a" && docker compose start lab06-a-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && rmdir /s /q "data\lab06-a" && tar -xf nodered-limpo.zip && docker compose start lab06-a-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-b(usuário, tópicos MQTTlab06-b/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-b\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-b\docker\lab06-b
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-b/
- Dashboard: http://localhost/lab06-b/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-b-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo b --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-b-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-b\data\lab06-b. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-b-nodered && rmdir /s /q "data\lab06-b" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo b --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-b-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-b-nodered && (rmdir /s /q "data\lab06-b\node_modules" 2>nul & del /q "data\lab06-b\package.json" "data\lab06-b\package-lock.json" "data\lab06-b\.config.nodes.json" 2>nul & docker compose start lab06-b-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-b desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-b-nodered && git checkout -- "data\lab06-b" && git clean -fdq "data\lab06-b" && docker compose start lab06-b-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-b-nodered && tar -a -cf nodered-limpo.zip "data\lab06-b" && docker compose start lab06-b-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-b-nodered && rmdir /s /q "data\lab06-b" && tar -xf nodered-limpo.zip && docker compose start lab06-b-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo b --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-c(usuário, tópicos MQTTlab06-c/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-c\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-c\docker\lab06-c
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-c/
- Dashboard: http://localhost/lab06-c/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-c-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo c --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-c-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-c\data\lab06-c. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-c-nodered && rmdir /s /q "data\lab06-c" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo c --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-c-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-c-nodered && (rmdir /s /q "data\lab06-c\node_modules" 2>nul & del /q "data\lab06-c\package.json" "data\lab06-c\package-lock.json" "data\lab06-c\.config.nodes.json" 2>nul & docker compose start lab06-c-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-c desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-c-nodered && git checkout -- "data\lab06-c" && git clean -fdq "data\lab06-c" && docker compose start lab06-c-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-c-nodered && tar -a -cf nodered-limpo.zip "data\lab06-c" && docker compose start lab06-c-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-c-nodered && rmdir /s /q "data\lab06-c" && tar -xf nodered-limpo.zip && docker compose start lab06-c-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo c --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-d(usuário, tópicos MQTTlab06-d/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-d\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-d\docker\lab06-d
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-d/
- Dashboard: http://localhost/lab06-d/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-d-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo d --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-d-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-d\data\lab06-d. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-d-nodered && rmdir /s /q "data\lab06-d" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo d --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-d-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-d-nodered && (rmdir /s /q "data\lab06-d\node_modules" 2>nul & del /q "data\lab06-d\package.json" "data\lab06-d\package-lock.json" "data\lab06-d\.config.nodes.json" 2>nul & docker compose start lab06-d-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-d desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-d-nodered && git checkout -- "data\lab06-d" && git clean -fdq "data\lab06-d" && docker compose start lab06-d-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-d-nodered && tar -a -cf nodered-limpo.zip "data\lab06-d" && docker compose start lab06-d-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-d-nodered && rmdir /s /q "data\lab06-d" && tar -xf nodered-limpo.zip && docker compose start lab06-d-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo d --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-e(usuário, tópicos MQTTlab06-e/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-e\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-e\docker\lab06-e
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-e/
- Dashboard: http://localhost/lab06-e/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-e-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo e --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-e-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-e\data\lab06-e. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-e-nodered && rmdir /s /q "data\lab06-e" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo e --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-e-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-e-nodered && (rmdir /s /q "data\lab06-e\node_modules" 2>nul & del /q "data\lab06-e\package.json" "data\lab06-e\package-lock.json" "data\lab06-e\.config.nodes.json" 2>nul & docker compose start lab06-e-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-e desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-e-nodered && git checkout -- "data\lab06-e" && git clean -fdq "data\lab06-e" && docker compose start lab06-e-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-e-nodered && tar -a -cf nodered-limpo.zip "data\lab06-e" && docker compose start lab06-e-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-e-nodered && rmdir /s /q "data\lab06-e" && tar -xf nodered-limpo.zip && docker compose start lab06-e-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo e --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-f(usuário, tópicos MQTTlab06-f/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-f\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-f\docker\lab06-f
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-f/
- Dashboard: http://localhost/lab06-f/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-f-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo f --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-f-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-f\data\lab06-f. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-f-nodered && rmdir /s /q "data\lab06-f" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo f --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-f-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-f-nodered && (rmdir /s /q "data\lab06-f\node_modules" 2>nul & del /q "data\lab06-f\package.json" "data\lab06-f\package-lock.json" "data\lab06-f\.config.nodes.json" 2>nul & docker compose start lab06-f-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-f desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-f-nodered && git checkout -- "data\lab06-f" && git clean -fdq "data\lab06-f" && docker compose start lab06-f-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-f-nodered && tar -a -cf nodered-limpo.zip "data\lab06-f" && docker compose start lab06-f-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-f-nodered && rmdir /s /q "data\lab06-f" && tar -xf nodered-limpo.zip && docker compose start lab06-f-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo f --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-g(usuário, tópicos MQTTlab06-g/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-g\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-g\docker\lab06-g
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-g/
- Dashboard: http://localhost/lab06-g/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-g-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo g --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-g-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-g\data\lab06-g. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-g-nodered && rmdir /s /q "data\lab06-g" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo g --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-g-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-g-nodered && (rmdir /s /q "data\lab06-g\node_modules" 2>nul & del /q "data\lab06-g\package.json" "data\lab06-g\package-lock.json" "data\lab06-g\.config.nodes.json" 2>nul & docker compose start lab06-g-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-g desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-g-nodered && git checkout -- "data\lab06-g" && git clean -fdq "data\lab06-g" && docker compose start lab06-g-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-g-nodered && tar -a -cf nodered-limpo.zip "data\lab06-g" && docker compose start lab06-g-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-g-nodered && rmdir /s /q "data\lab06-g" && tar -xf nodered-limpo.zip && docker compose start lab06-g-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo g --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-h(usuário, tópicos MQTTlab06-h/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-h\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-h\docker\lab06-h
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-h/
- Dashboard: http://localhost/lab06-h/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-h-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo h --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-h-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-h\data\lab06-h. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-h-nodered && rmdir /s /q "data\lab06-h" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo h --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-h-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-h-nodered && (rmdir /s /q "data\lab06-h\node_modules" 2>nul & del /q "data\lab06-h\package.json" "data\lab06-h\package-lock.json" "data\lab06-h\.config.nodes.json" 2>nul & docker compose start lab06-h-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-h desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-h-nodered && git checkout -- "data\lab06-h" && git clean -fdq "data\lab06-h" && docker compose start lab06-h-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-h-nodered && tar -a -cf nodered-limpo.zip "data\lab06-h" && docker compose start lab06-h-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-h-nodered && rmdir /s /q "data\lab06-h" && tar -xf nodered-limpo.zip && docker compose start lab06-h-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo h --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-i(usuário, tópicos MQTTlab06-i/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-i\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-i\docker\lab06-i
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-i/
- Dashboard: http://localhost/lab06-i/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-i-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo i --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-i-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-i\data\lab06-i. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-i-nodered && rmdir /s /q "data\lab06-i" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo i --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-i-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-i-nodered && (rmdir /s /q "data\lab06-i\node_modules" 2>nul & del /q "data\lab06-i\package.json" "data\lab06-i\package-lock.json" "data\lab06-i\.config.nodes.json" 2>nul & docker compose start lab06-i-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-i desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-i-nodered && git checkout -- "data\lab06-i" && git clean -fdq "data\lab06-i" && docker compose start lab06-i-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-i-nodered && tar -a -cf nodered-limpo.zip "data\lab06-i" && docker compose start lab06-i-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-i-nodered && rmdir /s /q "data\lab06-i" && tar -xf nodered-limpo.zip && docker compose start lab06-i-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo i --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-j(usuário, tópicos MQTTlab06-j/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-j\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-j\docker\lab06-j
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-j/
- Dashboard: http://localhost/lab06-j/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-j-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo j --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-j-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-j\data\lab06-j. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-j-nodered && rmdir /s /q "data\lab06-j" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo j --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-j-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-j-nodered && (rmdir /s /q "data\lab06-j\node_modules" 2>nul & del /q "data\lab06-j\package.json" "data\lab06-j\package-lock.json" "data\lab06-j\.config.nodes.json" 2>nul & docker compose start lab06-j-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-j desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-j-nodered && git checkout -- "data\lab06-j" && git clean -fdq "data\lab06-j" && docker compose start lab06-j-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-j-nodered && tar -a -cf nodered-limpo.zip "data\lab06-j" && docker compose start lab06-j-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-j-nodered && rmdir /s /q "data\lab06-j" && tar -xf nodered-limpo.zip && docker compose start lab06-j-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo j --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-k(usuário, tópicos MQTTlab06-k/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-k\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-k\docker\lab06-k
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-k/
- Dashboard: http://localhost/lab06-k/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-k-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo k --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-k-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-k\data\lab06-k. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-k-nodered && rmdir /s /q "data\lab06-k" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo k --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-k-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-k-nodered && (rmdir /s /q "data\lab06-k\node_modules" 2>nul & del /q "data\lab06-k\package.json" "data\lab06-k\package-lock.json" "data\lab06-k\.config.nodes.json" 2>nul & docker compose start lab06-k-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-k desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-k-nodered && git checkout -- "data\lab06-k" && git clean -fdq "data\lab06-k" && docker compose start lab06-k-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-k-nodered && tar -a -cf nodered-limpo.zip "data\lab06-k" && docker compose start lab06-k-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-k-nodered && rmdir /s /q "data\lab06-k" && tar -xf nodered-limpo.zip && docker compose start lab06-k-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo k --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-l(usuário, tópicos MQTTlab06-l/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-l\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-l\docker\lab06-l
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-l/
- Dashboard: http://localhost/lab06-l/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-l-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo l --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-l-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-l\data\lab06-l. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-l-nodered && rmdir /s /q "data\lab06-l" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo l --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-l-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-l-nodered && (rmdir /s /q "data\lab06-l\node_modules" 2>nul & del /q "data\lab06-l\package.json" "data\lab06-l\package-lock.json" "data\lab06-l\.config.nodes.json" 2>nul & docker compose start lab06-l-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-l desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-l-nodered && git checkout -- "data\lab06-l" && git clean -fdq "data\lab06-l" && docker compose start lab06-l-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-l-nodered && tar -a -cf nodered-limpo.zip "data\lab06-l" && docker compose start lab06-l-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-l-nodered && rmdir /s /q "data\lab06-l" && tar -xf nodered-limpo.zip && docker compose start lab06-l-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo l --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-m(usuário, tópicos MQTTlab06-m/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-m\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-m\docker\lab06-m
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-m/
- Dashboard: http://localhost/lab06-m/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-m-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo m --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-m-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-m\data\lab06-m. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-m-nodered && rmdir /s /q "data\lab06-m" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo m --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-m-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-m-nodered && (rmdir /s /q "data\lab06-m\node_modules" 2>nul & del /q "data\lab06-m\package.json" "data\lab06-m\package-lock.json" "data\lab06-m\.config.nodes.json" 2>nul & docker compose start lab06-m-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-m desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-m-nodered && git checkout -- "data\lab06-m" && git clean -fdq "data\lab06-m" && docker compose start lab06-m-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-m-nodered && tar -a -cf nodered-limpo.zip "data\lab06-m" && docker compose start lab06-m-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-m-nodered && rmdir /s /q "data\lab06-m" && tar -xf nodered-limpo.zip && docker compose start lab06-m-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo m --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
- Conta:
lab06-x(usuário, tópicos MQTTlab06-x/#) - Gerador (
%IOT_GEN%):%USERPROFILE%\ELT73AS22\lab06-grupo-x\docker\gen_iot_aluno.py - Pasta do LAB IoT (
%IOT_DIR%):%USERPROFILE%\ELT73AS22\lab06-grupo-x\docker\lab06-x
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab06 --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. Listar e exibir o status dos containers:
docker compose ps
5. Veja suas credenciais:
cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt
6. Abra o portal:
start http://localhost/
7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:
cd /d "%IOT_DIR%" && docker compose down
Se quiser, feche também o Docker Desktop para liberar a memória:
docker desktop stop
Endereços
- Portal: http://localhost/
- Node-RED: http://localhost/lab06-x/
- Dashboard: http://localhost/lab06-x/dashboard
- MQTT Explorer: http://localhost:3001/
- Material de ELT73A: http://localhost/mic-docs/
- MQTT (ESP32 na mesma rede):
<IP-da-máquina>:1883
Operações com Docker
Subir de novo (depois de reiniciar o PC ou de um down):
cd /d "%IOT_DIR%" && docker compose up -d
Parar (os dados ficam):
cd /d "%IOT_DIR%" && docker compose down
Reiniciar tudo:
cd /d "%IOT_DIR%" && docker compose restart
Ver erros do Node-RED (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f lab06-x-nodered
Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo x --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-x-nodered mosquitto
Atualizar as imagens:
cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d
Atualizar agora o material de ELT73A no portal:
cd /d "%IOT_DIR%" && docker compose restart docs
Acompanhar o download do material (Ctrl+C para sair):
cd /d "%IOT_DIR%" && docker compose logs -f docs
Wireshark ao vivo (só MQTT):
cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.
cd /d "%IOT_DIR%" && docker compose down -v
Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).
Limpar (voltar ao original)
Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-x\data\lab06-x. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.
Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.
cd /d "%IOT_DIR%" && docker compose stop lab06-x-nodered && rmdir /s /q "data\lab06-x" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo x --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-x-nodered
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)
Só os nós instalados pela paleta (Manage palette):
cd /d "%IOT_DIR%" && docker compose stop lab06-x-nodered && (rmdir /s /q "data\lab06-x\node_modules" 2>nul & del /q "data\lab06-x\package.json" "data\lab06-x\package-lock.json" "data\lab06-x\.config.nodes.json" 2>nul & docker compose start lab06-x-nodered)
Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-x desde então.
cd /d "%IOT_DIR%" && docker compose stop lab06-x-nodered && git checkout -- "data\lab06-x" && git clean -fdq "data\lab06-x" && docker compose start lab06-x-nodered
Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):
cd /d "%IOT_DIR%" && docker compose stop lab06-x-nodered && tar -a -cf nodered-limpo.zip "data\lab06-x" && docker compose start lab06-x-nodered
Restaurar:
cd /d "%IOT_DIR%" && docker compose stop lab06-x-nodered && rmdir /s /q "data\lab06-x" && tar -xf nodered-limpo.zip && docker compose start lab06-x-nodered
Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.
cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul
Gerar e subir de novo:
py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo x --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build
Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.
Hello Docker!
git conferir docker
git add docker && git commit -m "T1: Hello Docker!" && 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 1 — SSD1306 no circuito
Execute os comandos para subir o stack do LAB06!
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": "elt73a - 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@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
adafruit/Adafruit SSD1306@2.5.13
adafruit/Adafruit GFX Library@1.11.11
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 dependencias do SSD1306
git conferir platformio.ini diagram.json
git add platformio.ini diagram.json && git commit -m "T2: Circuito e dependencias 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 T2.
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/t3-serial.txt
e uma captura do Wokwi com o display em evidencias/t3-oled.png.
- └── 📂evidencias
- ├── 📄t3-serial.txt👈 Criar Aqui
- └── 📄t3-oled.png👈 Criar Aqui
git conferir evidencias/t3-serial.txt evidencias/t3-oled.png
Tela local no OLED
git conferir src/main.cpp evidencias/t3-serial.txt evidencias/t3-oled.png
git add src/main.cpp evidencias/t3-serial.txt evidencias/t3-oled.png && git commit -m "T3: 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 T3.
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. - 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
// elt73a - Lab 06 (T4): 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 "elt73a/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 (T4)
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();
uint64_t mac = ESP.getEfuseMac();
snprintf(clientId, sizeof(clientId), "lab06-%s-%04X", GRUPO, (uint16_t)(mac >> 32));
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
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-a/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-a/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-a/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-b/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-b/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-b/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-c/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-c/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-c/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-d/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-d/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-d/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-e/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-e/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-e/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-f/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-f/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-f/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-g/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-g/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-g/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-h/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-h/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-h/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-i/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-i/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-i/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-j/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-j/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-j/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-k/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-k/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-k/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-l/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-l/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-l/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-m/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-m/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-m/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-x/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-x/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-x/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-p/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-p/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-p/cmd/intervalo" -m 1
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-n/#' -v | tee /ev/t4-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-n/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-n/cmd/intervalo" -m 1
Saída esperada (trecho; encerre o Terminal 1 com Ctrl+C depois de umas 8 linhas):
- └── 📂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
1. Exemplo de Evidência de Saída:
elt73a/lab06/grupo-a/status online
elt73a/lab06/grupo-a/dht {"grupo":"a","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-a/oled {"linhas":["LAB06 grupo a","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-a/cmd/intervalo 10
elt73a/lab06/grupo-a/oled {"linhas":["LAB06 grupo a","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-a/dht {"grupo":"a","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-a/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-b/status online
elt73a/lab06/grupo-b/dht {"grupo":"b","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-b/oled {"linhas":["LAB06 grupo b","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-b/cmd/intervalo 10
elt73a/lab06/grupo-b/oled {"linhas":["LAB06 grupo b","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-b/dht {"grupo":"b","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-b/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-c/status online
elt73a/lab06/grupo-c/dht {"grupo":"c","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-c/oled {"linhas":["LAB06 grupo c","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-c/cmd/intervalo 10
elt73a/lab06/grupo-c/oled {"linhas":["LAB06 grupo c","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-c/dht {"grupo":"c","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-c/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-d/status online
elt73a/lab06/grupo-d/dht {"grupo":"d","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-d/oled {"linhas":["LAB06 grupo d","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-d/cmd/intervalo 10
elt73a/lab06/grupo-d/oled {"linhas":["LAB06 grupo d","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-d/dht {"grupo":"d","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-d/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-e/status online
elt73a/lab06/grupo-e/dht {"grupo":"e","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-e/oled {"linhas":["LAB06 grupo e","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-e/cmd/intervalo 10
elt73a/lab06/grupo-e/oled {"linhas":["LAB06 grupo e","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-e/dht {"grupo":"e","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-e/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-f/status online
elt73a/lab06/grupo-f/dht {"grupo":"f","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-f/oled {"linhas":["LAB06 grupo f","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-f/cmd/intervalo 10
elt73a/lab06/grupo-f/oled {"linhas":["LAB06 grupo f","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-f/dht {"grupo":"f","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-f/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-g/status online
elt73a/lab06/grupo-g/dht {"grupo":"g","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-g/oled {"linhas":["LAB06 grupo g","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-g/cmd/intervalo 10
elt73a/lab06/grupo-g/oled {"linhas":["LAB06 grupo g","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-g/dht {"grupo":"g","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-g/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-h/status online
elt73a/lab06/grupo-h/dht {"grupo":"h","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-h/oled {"linhas":["LAB06 grupo h","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-h/cmd/intervalo 10
elt73a/lab06/grupo-h/oled {"linhas":["LAB06 grupo h","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-h/dht {"grupo":"h","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-h/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-i/status online
elt73a/lab06/grupo-i/dht {"grupo":"i","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-i/oled {"linhas":["LAB06 grupo i","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-i/cmd/intervalo 10
elt73a/lab06/grupo-i/oled {"linhas":["LAB06 grupo i","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-i/dht {"grupo":"i","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-i/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-j/status online
elt73a/lab06/grupo-j/dht {"grupo":"j","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-j/oled {"linhas":["LAB06 grupo j","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-j/cmd/intervalo 10
elt73a/lab06/grupo-j/oled {"linhas":["LAB06 grupo j","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-j/dht {"grupo":"j","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-j/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-k/status online
elt73a/lab06/grupo-k/dht {"grupo":"k","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-k/oled {"linhas":["LAB06 grupo k","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-k/cmd/intervalo 10
elt73a/lab06/grupo-k/oled {"linhas":["LAB06 grupo k","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-k/dht {"grupo":"k","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-k/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-l/status online
elt73a/lab06/grupo-l/dht {"grupo":"l","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-l/oled {"linhas":["LAB06 grupo l","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-l/cmd/intervalo 10
elt73a/lab06/grupo-l/oled {"linhas":["LAB06 grupo l","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-l/dht {"grupo":"l","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-l/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-m/status online
elt73a/lab06/grupo-m/dht {"grupo":"m","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-m/oled {"linhas":["LAB06 grupo m","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-m/cmd/intervalo 10
elt73a/lab06/grupo-m/oled {"linhas":["LAB06 grupo m","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-m/dht {"grupo":"m","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-m/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-x/status online
elt73a/lab06/grupo-x/dht {"grupo":"x","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-x/oled {"linhas":["LAB06 grupo x","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-x/cmd/intervalo 10
elt73a/lab06/grupo-x/oled {"linhas":["LAB06 grupo x","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-x/dht {"grupo":"x","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-x/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-p/status online
elt73a/lab06/grupo-p/dht {"grupo":"p","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-p/oled {"linhas":["LAB06 grupo p","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-p/cmd/intervalo 10
elt73a/lab06/grupo-p/oled {"linhas":["LAB06 grupo p","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-p/dht {"grupo":"p","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-p/cmd/intervalo 1
elt73a/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:
elt73a/lab06/grupo-n/status online
elt73a/lab06/grupo-n/dht {"grupo":"n","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-n/oled {"linhas":["LAB06 grupo n","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-n/cmd/intervalo 10
elt73a/lab06/grupo-n/oled {"linhas":["LAB06 grupo n","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-n/dht {"grupo":"n","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-n/cmd/intervalo 1
elt73a/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/t4-mqtt.txt
git add src/main.cpp evidencias/t4-mqtt.txt && git commit -m "T4: 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 T4.
Parte 4 — Node-RED: réplica do OLED e comando do intervalo
O Node-RED desta aula é mínimo: três fluxos curtos, sem nenhum nó function. Ele só mostra o que o ESP32 publica e devolve o comando do intervalo. Guardar as leituras num banco e consultar o histórico fica para o Lab 08.
No Dashboard 2.0 da stack (My Dashboard, em http://localhost:1880/dashboard), crie uma
página Lab 06 (caminho /lab06) com dois grupos: Tela OLED (SSD1306) (largura 6) e
ESP32 (largura 3).
Todos os mqtt in usam o mesmo broker do Lab 05 (broker.hivemq.com:1883).
4.1 Réplica do OLED em texto
mqtt in elt73a/lab06/grupo-x/oled (Output: a parsed JSON object) → ui-template
"OLED em texto" (grupo Tela OLED, largura 3, altura 4). 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>
4.2 Status e intervalo
| Nó | Configuração |
|---|---|
| mqtt in "status (LWT)" | elt73a/lab06/grupo-x/status, Output a String → ui-text "ESP32" (grupo ESP32) |
| mqtt in "leituras DHT22" | elt73a/lab06/grupo-x/dht, Output a parsed JSON object |
| change "payload = intervalo_s" | Set msg.payload to the value msg.payload.intervalo_s |
| filter "só se mudou" | Mode block unless value changes (só deixa passar quando o intervalo muda) |
| ui-slider "Intervalo de leitura (s)" | grupo ESP32, 2 a 60, passo 1, Topic elt73a/lab06/grupo-x/cmd/intervalo, Output on release, pass-through desligado |
| mqtt out | tópico vazio (usa o msg.topic do slider) |
Com pass-through desligado, uma mensagem que chega no slider só move o cursor: ela
não sai pelo mqtt out. E o filter só deixa passar o intervalo_s quando o ESP32
confirma um valor novo. Assim o slider mostra o valor em uso, e não só o último pedido.
Abra http://localhost:1880/dashboard/lab06, mova o slider para 10 s e confira:
- o rodapé do OLED no Wokwi e a réplica em texto mudam para
int 10 s; - o monitor serial mostra
[CMD] novo intervalo: 10.0 s; - as leituras passam a chegar a cada 10 s.
Evidências: captura do dashboard em evidencias/t5-dashboard.png e a aba Lab 06
exportada (menu → Export → Current flow) em nodered/flows-lab06.json.
- ├── 📂nodered
- └── 🔧flows-lab06.json👈 Criar Aqui
- └── 📂evidencias
- └── 📄t5-dashboard.png👈 Criar Aqui
git conferir nodered/flows-lab06.json evidencias/t5-dashboard.png
Node-RED: replica do OLED e comando do intervalo
git conferir nodered/flows-lab06.json evidencias/t5-dashboard.png
git add nodered/flows-lab06.json evidencias/t5-dashboard.png && git commit -m "T5: Node-RED: replica do OLED e comando do intervalo" && 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
elt73a/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 da T5, 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 --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-a/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-b/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-c/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-d/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-e/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-f/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-g/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-h/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-i/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-j/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-k/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-l/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-m/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-x/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-p/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-n/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
1369
São 1368 caracteres base64 mais a quebra de linha que o mosquitto_sub acrescenta.
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>
P3: quantos bytes cada atualização da tela custa no broker em cada versão: texto (.../oled)
× framebuffer (.../oled/fb)? Qual das duas daria para guardar num banco e consultar com
SQL (como no Lab 08), 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
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.