Laboratório 02
Checklist — ambiente de desenvolvimento (parte 2): PlatformIO, Wokwi e Docker
- Extensões PlatformIO IDE e Wokwi Simulator no perfil
ESP32IO, com opiono Path (Parte 1) - Projeto PlatformIO na versão mais recente da plataforma (registrada na evidência), compilando, sem a
.pio/no repositório (T1) - Licença do Wokwi ativada,
wokwi.toml+diagram.jsone o pisca-LED simulado no VS Code (T2) - Pisca sem
delay()(commillis()) e um breakpoint do GDB parando o firmware no Wokwi (T3) - Docker funcionando,
Dockerfile+compose.yamle o firmware compilado dentro do container (T4) - Firmware simulado pelo
wokwi-clino container, com teste automático do serial (T5) - Previsões P1–P3 respondidas no
README.md - Nenhum token no repositório; nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
T1…T5 = 100 pts (esta aula não tem desafios): T1 15 · T2 20 · T3 15 · T4 20 · T5 30. 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
No Lab 01, o grupo passou a usar o Git e o GitHub. Agora entra o firmware: o
PlatformIO compila o código do ESP32, e o Wokwi o roda num ESP32 simulado dentro do
VS Code, com LED, monitor serial e depurador (GDB). E entra a última ferramenta do ambiente, o
Docker: o mesmo build e a mesma simulação passam a rodar num container Linux, igual em
qualquer computador, sem depender do que está instalado no Windows. É exatamente o que o CI do
Lab 11 vai fazer a cada push. O MQTT fica para o Lab 04.
Objetivos
- Instalar o PlatformIO e o Wokwi no VS Code e fazer o primeiro build do ESP32.
- Configurar um projeto PlatformIO e registrar a versão da plataforma que o build usou.
- Ativar o Wokwi no VS Code e ligar o firmware do PlatformIO ao circuito (
wokwi.toml,diagram.json). - Trocar o
delay()pormillis(), o padrão que todos os labs seguintes usam, e depurar o firmware simulado com o GDB. - Instalar o Docker, escrever um
Dockerfilee umcompose.yaml, e compilar e simular o firmware num container com owokwi-cli.
Material
- O ambiente do Lab 01: Windows 11, VS Code, Git,
gh, Python, e o terminal do VS Code no Prompt de Comando (cmd). - ~6 GB livres: o toolchain do ESP32 (~300 MB no Windows e de novo no container) e a imagem do Docker.
- Uma conta no Wokwi (gratuita): a licença do simulador no VS Code e o token de CI do
wokwi-cli. - Docker Desktop com WSL 2 (aba Docker da configuração do ambiente).
- Nenhuma placa. A Parte 6 mostra como gravar uma placa real, para quem tiver.
PlatformIO, Wokwi (extensão e licença), Docker (WSL 2 e Docker Desktop) e, só para
quem tiver placa, Drivers. As demais já foram feitas no Lab 01. O wokwi-cli não precisa
ser instalado no Windows: ele roda dentro do container.
O Wokwi simula o ESP32 (incluindo o Wi-Fi), LEDs, potenciômetros, o DHT22, o display SSD1306 e
um analisador lógico. Todo o semestre roda nele: ninguém depende da bancada, do cabo USB ou do
driver da placa, e o mesmo circuito (diagram.json) vai para o repositório junto com o código.
No Lab 11, o mesmo simulador roda sem interface, dentro do CI, com os mesmos comandos
(pio run e wokwi-cli) que você roda hoje no container.
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/lab02-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-a/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-a.git && cd lab02-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-b/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-b.git && cd lab02-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-c/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-c.git && cd lab02-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-d/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-d.git && cd lab02-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-e/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-e.git && cd lab02-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-f/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-f.git && cd lab02-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-g/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-g.git && cd lab02-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-h/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-h.git && cd lab02-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-i/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-i.git && cd lab02-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-j/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-j.git && cd lab02-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-k/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-k.git && cd lab02-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-l/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-l.git && cd lab02-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-m/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-m.git && cd lab02-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-x/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-x.git && cd lab02-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-p/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-p.git && cd lab02-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab02-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab02-grupo-n/commits/main/
- Acessos: ACESSO-LAB02.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/lab02-grupo-n.git && cd lab02-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab02-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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- 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 02:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Cada cartão Ponto de commit é uma tarefa: faça-a, copie o comando do cartão e rode. A mensagem começa com o código (T1:, T2:…) — é como a correção identifica sua entrega. Um commit por tarefa; pode refazer (vale o mais recente); e não esqueça o git push. Detalhes em Como funciona a avaliação.
Mapa de tarefas — 5 tarefas · 100 pts
- T1 — Projeto PlatformIO · 15 pts
- T2 — Wokwi no VS Code · 20 pts
- T3 — Pisca com millis e GDB · 15 pts
- T4 — Docker: build no container · 20 pts
- T5 — Simulação no container com o wokwi-cli · 30 pts
O repositório nasce do lab02-template, com o README.md e o .gitignore:
Estrutura de Arquivos do Projeto (no fim da aula)
- ├── 📄.gitignore👈 Edite Aqui
- ├── 📄.dockerignore👈 Criar Aqui
- ├── 📂.vscode
- ├── 🔧settings.json👈 Verificar
- └── 🔧launch.json👈 Criar Aqui
- ├── 📄Dockerfile👈 Criar Aqui
- ├── 🚀compose.yaml👈 Criar Aqui
- ├── 📝README.md👈 Edite Aqui
- ├── 🔧platformio.ini👈 Criar Aqui
- ├── 📂src
- └── 📄main.cpp👈 Criar Aqui
- ├── 📂include
- └── 📄README👈 Criar Aqui
- ├── 📂lib
- └── 📄README👈 Criar Aqui
- ├── 📂test
- └── 📄README👈 Criar Aqui
- ├── 🔧wokwi.toml👈 Criar Aqui
- ├── 🔧diagram.json👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t1-ambiente.txt👈 Criar Aqui
- ├── 📄t1-build.txt👈 Criar Aqui
- ├── 📄t2-serial.txt👈 Criar Aqui
- ├── 📄t2-wokwi.png👈 Criar Aqui
- ├── 📄t3-serial.txt👈 Criar Aqui
- ├── 📄t3-gdb.png👈 Criar Aqui
- ├── 📄t4-docker.txt👈 Criar Aqui
- ├── 📄t4-build-docker.txt👈 Criar Aqui
- ├── 📄t5-wokwi.txt👈 Criar Aqui
- └── 📄t5-serial.txt👈 Criar Aqui
Parte 1 — PlatformIO: instalação e projeto
1.1 Instalar as extensões
Siga as abas PlatformIO e Wokwi da configuração do ambiente. As extensões vão
para o perfil ESP32IO do VS Code (--profile "ESP32IO"), o mesmo em que você abriu o
repositório no Lab 01:
code --install-extension platformio.platformio-ide --profile "ESP32IO"
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"
Abra o repositório do grupo nesse perfil e confira que o terminal é o cmd (o
.vscode/settings.json do Lab 01; se o template não o trouxer, crie-o de novo):
cd lab02-grupo-x
code --profile "ESP32IO" .
Na primeira vez que o VS Code abrir com a extensão do PlatformIO, ela instala o PlatformIO
Core (barra de status: Installing PlatformIO Core). Espere terminar e recarregue a janela
quando ele pedir. É essa instalação que cria a pasta %USERPROFILE%\.platformio\penv\Scripts\,
que a aba PlatformIO manda pôr no Path. Depois de pôr, feche e abra o VS Code e
confira:
pio --version
call code --list-extensions --profile "ESP32IO"
Se aparecer 'pio' não é reconhecido como um comando interno, falta o Path; se a pasta não existir, o PlatformIO Core ainda não terminou de instalar.
1.2 Criar o projeto
No terminal do VS Code, na raiz do repositório:
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200"
The following files/directories have been created in C:\...\lab02-grupo-x
include - Put project header files here
lib - Put project specific (private) libraries here
src - Put project source files here
platformio.ini - Project Configuration File
Resolving esp32dev dependencies...
Project has been successfully initialized!
O pio project init cria platformio.ini, src/, include/, lib/ e test/, e não apaga o
README.md nem o .vscode/settings.json. (A aba PlatformIO mostra o mesmo comando com
--ide vscode --sample-code: o primeiro gera arquivos de configuração do VS Code, o segundo um
main.cpp de exemplo. Aqui você escreve o seu.)
1.3 Versão da plataforma
O pio project init escreve platform = espressif32, sem versão: o PlatformIO usa a versão
mais recente da plataforma (e, com ela, do core Arduino e do toolchain). É o padrão desta
disciplina, e vale também para as bibliotecas dos labs seguintes. O preço é que o mesmo código
pode se comportar diferente quando sai uma versão nova; por isso a versão usada fica
registrada na evidência do build (as linhas PLATFORM: e PACKAGES: no início do
pio run). Para trazer a versão nova de algo já instalado: pio pkg update.
[env:esp32dev]
platform = espressif32 ; sem versão: a mais recente
board = esp32dev
framework = arduino
monitor_speed = 115200 ; o mesmo valor do Serial.begin()
1.4 Pisca-LED e primeiro build
Crie src/main.cpp:
#include <Arduino.h>
#define LED_PIN 2 // GPIO2 (o LED do circuito da Parte 2)
// Protótipo: em C/C++ uma função precisa ser declarada antes de ser usada
void piscar(uint8_t pino, uint16_t meioPeriodoMs);
void setup() {
Serial.begin(115200); // o mesmo valor do monitor_speed do platformio.ini
pinMode(LED_PIN, OUTPUT);
Serial.println("ESP32 inicializado! Lab 02, grupo X");
}
void loop() {
piscar(LED_PIN, 500);
}
void piscar(uint8_t pino, uint16_t meioPeriodoMs) {
digitalWrite(pino, HIGH);
delay(meioPeriodoMs);
digitalWrite(pino, LOW);
delay(meioPeriodoMs);
}
O primeiro build baixa a plataforma espressif32, o toolchain Xtensa e o core
Arduino (~300 MB). Pode levar de 5 a 15 minutos; os seguintes levam segundos. Rode o primeiro
na tela, para acompanhar o download, e o segundo gravando a evidência:
pio run
if not exist evidencias mkdir evidencias
(echo == ambiente %DATE% %TIME% & pio --version & call code --list-extensions --profile "ESP32IO") > evidencias\t1-ambiente.txt 2>&1
pio run > evidencias\t1-build.txt 2>&1
type evidencias\t1-build.txt
RAM: [= ] 6.5% (used 21360 bytes from 327680 bytes)
Flash: [== ] 20.4% (used 267525 bytes from 1310720 bytes)
Building .pio/build/esp32dev/firmware.bin
========================= [SUCCESS] Took 41.27 seconds =========================
A barra de status do VS Code tem os mesmos comandos: ✓ Build (pio run), → Upload
(pio run -t upload), 🔌 Serial Monitor (pio device monitor) e 🗑 Clean. O terminal é
melhor para gerar evidências, porque o > arquivo 2>&1 grava a saída direto num arquivo. O
segundo pio run não recompila nada, mas imprime de novo o uso de RAM e Flash.
1.5 O que vai para o repositório
O git status mostra a pasta .pio/? Não deveria: o .gitignore do template a ignora. Ela
guarda o build inteiro (dezenas de MB, confira com dir /s .pio), muda a cada compilação e é
refeita por qualquer um com pio run. Nem o firmware.bin vai: ele é gerado a partir do
código, e no Lab 11 vai para outro lugar, uma release. Faça o commit só do que é código e
configuração:
git status
git add .vscode/settings.json platformio.ini src include lib test evidencias/t1-ambiente.txt evidencias/t1-build.txt
git commit -m "T1: projeto PlatformIO"
git push
- ├── 📂.vscode
- └── 🔧settings.json👈 Criar Aqui
- ├── 🔧platformio.ini👈 Criar Aqui
- ├── 📂src
- └── 📄main.cpp👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t1-ambiente.txt👈 Criar Aqui
- └── 📄t1-build.txt👈 Criar Aqui
git conferir .vscode/settings.json platformio.ini src/main.cpp evidencias/t1-ambiente.txt evidencias/t1-build.txt
Projeto PlatformIO
git conferir .vscode/settings.json platformio.ini src/main.cpp evidencias/t1-ambiente.txt evidencias/t1-build.txt
git add .vscode/settings.json platformio.ini src/main.cpp evidencias/t1-ambiente.txt evidencias/t1-build.txt && git commit -m "T1: Projeto PlatformIO" && 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 — Wokwi no VS Code
2.1 Ativar a licença
Na aba Wokwi da configuração do ambiente, use o link Gerar uma licença pessoal de 30 dias (ou, no VS Code, F1 → Wokwi: Request a New License). O navegador abre o site do Wokwi: entre com a sua conta e confirme, e o navegador devolve a licença ao VS Code. Quando ela vencer, o VS Code avisa, e você repete o passo.
2.2 Ligar o firmware ao simulador
O Wokwi precisa de dois arquivos na raiz do projeto:
wokwi.toml: qual firmware rodar (o que o PlatformIO acabou de compilar);diagram.json: o circuito (placa, componentes, fios).
[wokwi]
version = 1
firmware = '.pio/build/esp32dev/firmware.bin'
elf = '.pio/build/esp32dev/firmware.elf'
Use / nos caminhos, mesmo no Windows: o arquivo vai para o repositório e precisa funcionar
nos computadores de todos e no container Linux da Parte 4.
{
"version": 1,
"author": "ELT85B - Lab 02",
"editor": "wokwi",
"parts": [
{
"type": "board-esp32-devkit-c-v4",
"id": "esp",
"top": 0,
"left": 0,
"attrs": {}
},
{
"type": "wokwi-resistor",
"id": "r1",
"top": 130,
"left": 120,
"attrs": { "value": "220" }
},
{
"type": "wokwi-led",
"id": "led1",
"top": 80,
"left": 220,
"attrs": { "color": "red", "label": "GPIO2" }
}
],
"connections": [
["esp:TX", "$serialMonitor:RX", "", []],
["esp:RX", "$serialMonitor:TX", "", []],
["esp:2", "r1:1", "green", []],
["r1:2", "led1:A", "green", []],
["led1:C", "esp:GND.2", "black", []]
],
"dependencies": {}
}
| Linha | O que liga |
|---|---|
esp:TX → $serialMonitor:RX (e o inverso) | a UART0 do ESP32 ao monitor serial do Wokwi (o Serial.println) |
esp:2 → resistor → led1:A | o GPIO2 ao anodo do LED, passando por 220 Ω (limita a corrente em ~6 mA) |
led1:C → esp:GND.2 | o catodo do LED ao terra |
Abra o diagram.json no VS Code: o editor do Wokwi mostra o circuito ao lado, e você pode
arrastar as peças. Os labs seguintes acrescentam componentes a este mesmo arquivo.
2.3 Simular
- Compile (
pio run): o Wokwi roda o últimofirmware.bincompilado. - F1 → Wokwi: Start Simulator (ou clique no
diagram.jsone em ▶). - O LED pisca, e o monitor serial (abaixo do circuito) mostra
ESP32 inicializado!.
Salve o monitor serial em evidencias/t2-serial.txt (selecione o texto e copie) e uma captura
do VS Code com o circuito e o serial em evidencias/t2-wokwi.png.
P1: (a) você mudou o LED_PIN para 4 e iniciou o simulador sem compilar de novo. O que
o Wokwi mostra: o código novo ou o antigo? Por quê? (b) No canto do simulador aparece a
porcentagem de tempo real (ex.: 98%). Se ela cair para 50 %, o LED pisca mais devagar na
tela? E o millis() do ESP32: conta o tempo simulado ou o do relógio da parede?
- ├── 🔧wokwi.toml👈 Criar Aqui
- ├── 🔧diagram.json👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t2-serial.txt👈 Criar Aqui
- └── 📄t2-wokwi.png👈 Criar Aqui
git conferir wokwi.toml diagram.json evidencias/t2-serial.txt evidencias/t2-wokwi.png
Wokwi no VS Code
git conferir wokwi.toml diagram.json evidencias/t2-serial.txt evidencias/t2-wokwi.png
git add wokwi.toml diagram.json evidencias/t2-serial.txt evidencias/t2-wokwi.png && git commit -m "T2: Wokwi no VS Code" && 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 — Pisca com millis() e depuração com GDB
3.1 Sem delay()
Com delay(500), o ESP32 fica parado meio segundo e não faz mais nada: não lê a serial, não
atende o Wi-Fi, não confere um botão. Os labs seguintes fazem várias coisas "ao mesmo tempo",
então o padrão é outro: o loop() gira o tempo todo e cada tarefa confere se já deu a hora.
#include <Arduino.h>
#define LED_PIN 2
#define MEIO_PERIODO 500 // ms aceso, ms apagado
#define RELATORIO_MS 2000 // a cada 2 s, uma linha no serial
unsigned long tLed = 0, tRelatorio = 0;
bool ledAceso = false;
uint32_t voltas = 0; // quantas vezes o loop() rodou
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
Serial.println("ESP32 inicializado! Lab 02, grupo X");
}
void loop() {
unsigned long agora = millis();
voltas++;
if (agora - tLed >= MEIO_PERIODO) { // já deu a hora de trocar o LED?
tLed += MEIO_PERIODO;
ledAceso = !ledAceso;
digitalWrite(LED_PIN, ledAceso ? HIGH : LOW);
}
if (agora - tRelatorio >= RELATORIO_MS) { // e a do relatório?
tRelatorio += RELATORIO_MS;
Serial.printf("[%7lu ms] LED %s · %lu voltas do loop() em 2 s\r\n",
agora, ledAceso ? "aceso " : "apagado", (unsigned long)voltas);
voltas = 0;
}
}
ESP32 inicializado! Lab 02, grupo X
[ 2000 ms] LED aceso · 1032915 voltas do loop() em 2 s
[ 4000 ms] LED aceso · 1035522 voltas do loop() em 2 s
[ 6000 ms] LED aceso · 1035519 voltas do loop() em 2 s
O loop() roda centenas de milhares de vezes por segundo, e o LED continua piscando no ritmo
certo. Com o pisca de delay da T1, seriam 2 voltas a cada 2 s.
P2: (a) o millis() é um unsigned long de 32 bits e volta a zero depois de ~49,7 dias.
Por que agora - tLed >= MEIO_PERIODO continua certo na virada, mas agora >= tLed + MEIO_PERIODO
não? Teste a conta com números de 32 bits: tLed = 4294967000, agora = 200. (b) Por que
tLed += MEIO_PERIODO e não tLed = agora? O que acontece com o ritmo do LED em cada caso, se
uma volta do loop() atrasar 3 ms?
Evidência: pelo menos 5 linhas do monitor serial em evidencias/t3-serial.txt.
3.2 Depurar com GDB no Wokwi
O Serial.printf mostra o que você mandou imprimir. O GDB para o firmware numa linha
(breakpoint) e mostra todas as variáveis naquele instante, sem mudar o código. O Wokwi
abre um servidor GDB na porta 3333, e o VS Code se conecta a ele.
-
Extensão C/C++ (fornece o depurador
cppdbgdo VS Code):Terminal (cmd)code --install-extension ms-vscode.cpptools --profile "ESP32IO" -
wokwi.toml: acrescente a porta do servidor GDB.wokwi.toml[wokwi]version = 1firmware = '.pio/build/esp32dev/firmware.bin'elf = '.pio/build/esp32dev/firmware.elf'gdbServerPort = 3333 -
.vscode/launch.json: diz ao VS Code qual GDB usar (o do toolchain do ESP32, baixado pelo PlatformIO), qual.elftem os símbolos e onde está o servidor..vscode/launch.json{"version": "0.2.0","configurations": [{"name": "Wokwi GDB","type": "cppdbg","request": "launch","program": "${workspaceFolder}/.pio/build/esp32dev/firmware.elf","cwd": "${workspaceFolder}","MIMode": "gdb","miDebuggerPath": "${userHome}/.platformio/packages/toolchain-xtensa-esp32/bin/xtensa-esp32-elf-gdb.exe","miDebuggerServerAddress": "localhost:3333"}]}Confira que o GDB existe nesse caminho:
Terminal do VS Code (cmd)dir "%USERPROFILE%\.platformio\packages\toolchain-xtensa-esp32\bin\*gdb*" -
Depurar. Compile (
pio run), depois F1 → Wokwi: Start Simulator and Wait for Debugger: o simulador abre parado, esperando o GDB. Clique na margem à esquerda da linhaledAceso = !ledAceso;(aparece um ponto vermelho) e aperte F5 (configuração Wokwi GDB). -
O firmware para no breakpoint. No painel Run and Debug, a seção Variables mostra
agora, e Watch aceita expressões (tLed,voltas,ledAceso). F5 continua até a próxima parada, F10 executa uma linha, F11 entra na função, Shift+F5 encerra.
Salve uma captura do VS Code parado no breakpoint, com as variáveis à vista, em
evidencias/t3-gdb.png.
O build padrão do PlatformIO é otimizado (-Os): o compilador guarda variáveis em
registradores ou as elimina, e o GDB mostra <optimized out>. Para depurar, acrescente
build_type = debug ao [env:esp32dev] do platformio.ini e compile de novo; retire-o depois.
Enquanto o firmware está parado no GDB, o tempo simulado também para: o millis() não
avança, e o LED não troca (compare com o P1-b).
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- ├── 🔧wokwi.toml👈 Edite Aqui
- ├── 📂.vscode
- └── 🔧launch.json👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t3-serial.txt👈 Criar Aqui
- └── 📄t3-gdb.png👈 Criar Aqui
git conferir src/main.cpp wokwi.toml .vscode/launch.json evidencias/t3-serial.txt evidencias/t3-gdb.png
Pisca com millis e GDB
git conferir src/main.cpp wokwi.toml .vscode/launch.json evidencias/t3-serial.txt evidencias/t3-gdb.png
git add src/main.cpp wokwi.toml .vscode/launch.json evidencias/t3-serial.txt evidencias/t3-gdb.png && git commit -m "T3: Pisca com millis e GDB" && 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 — Docker: o ambiente num container
Até aqui, o build depende do seu Windows: da versão do PlatformIO, do Path, do perfil do
VS Code. Um container é um Linux mínimo, descrito num arquivo de texto (Dockerfile), que
roda igual em qualquer computador com Docker. Se o firmware compila no container, compila no
computador do colega, no do professor e no CI.
| Peça | O que é |
|---|---|
Dockerfile | a receita da imagem: sistema base + o que instalar (PlatformIO, wokwi-cli) |
| imagem | o resultado do docker compose build: um "molde" pronto, guardado no Docker |
| container | uma execução da imagem; com --rm, é apagado quando o comando termina |
compose.yaml | como rodar: qual imagem, quais pastas montar, quais variáveis, qual comando de cada serviço |
| bind mount | a pasta do repositório aparece dentro do container em /projeto: o que ele grava, você vê |
| volume nomeado | uma pasta guardada pelo Docker entre execuções: aqui, o cache do PlatformIO (~300 MB) |
4.1 Instalar e conferir o Docker
Siga a aba Docker da configuração do ambiente: primeiro o WSL 2 (o
wsl --install pede para reiniciar o computador), depois o Docker Desktop. Abra o Docker
Desktop, aceite os termos e espere a baleia ficar parada na bandeja. Se ele reclamar de
virtualização, ative-a na BIOS/UEFI (Intel VT-x ou AMD-V).
Confira no terminal do VS Code e grave a evidência:
(wsl --version & docker --version & docker compose version & docker run --rm hello-world) > evidencias\t4-docker.txt 2>&1
type evidencias\t4-docker.txt
O hello-world baixa uma imagem minúscula, cria um container, imprime Hello from Docker! e
o container é apagado (--rm). O wsl --version escreve em UTF-16, e por isso pode aparecer
com espaços entre as letras no arquivo: tudo bem.
4.2 O Dockerfile
Na raiz do repositório, crie o Dockerfile (sem extensão):
# ELT85B - ambiente de build e simulação do ESP32 (os mesmos comandos do CI do Lab 11)
FROM python:3-slim
# curl: baixar o wokwi-cli · git: bibliotecas do PlatformIO vindas de repositórios
RUN apt-get update \
&& apt-get install -y --no-install-recommends curl ca-certificates git \
&& rm -rf /var/lib/apt/lists/*
RUN pip install --no-cache-dir platformio
# wokwi-cli: um único executável Linux, publicado no GitHub do Wokwi
RUN curl -fsSL -o /usr/local/bin/wokwi-cli \
https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-linuxstatic-x64 \
&& chmod +x /usr/local/bin/wokwi-cli \
&& wokwi-cli --version
WORKDIR /projeto
CMD ["pio", "--version"]
Cada RUN vira uma camada da imagem. O Docker guarda as camadas em cache: se você mudar só
a última linha, ele não instala o PlatformIO de novo. Por isso o que muda menos fica em cima.
Sem versão no Dockerfile, o build pega o Python, o PlatformIO e o wokwi-cli mais recentes;
para atualizar uma imagem já construída, use docker compose build --no-cache.
O contexto do build é a pasta inteira, enviada ao Docker antes de começar. O
.dockerignore tira dele o que a imagem não usa (e o .env da T5, que nunca deve entrar numa
imagem):
.git
.pio
.vscode
evidencias
.env
4.3 O compose.yaml
O docker compose guarda num arquivo os parâmetros que, com o docker run, você teria de
digitar a cada vez. Os três serviços usam a mesma imagem; muda só o comando:
# Configuração comum aos serviços (âncora YAML: &esp32 define, <<: *esp32 reutiliza)
x-esp32: &esp32
build: .
image: elt85b/esp32-dev:lab02
working_dir: /projeto
volumes:
- .:/projeto # o repositório, dentro do container
- platformio:/root/.platformio # cache do toolchain entre execuções
environment:
WOKWI_CLI_TOKEN: ${WOKWI_CLI_TOKEN:-} # vem do arquivo .env (T5), nunca do Git
services:
pio: # compilar
<<: *esp32
command: pio run
wokwi: # simular e testar o serial
<<: *esp32
command: >
wokwi-cli --timeout 10000 --expect-text "voltas do loop"
--serial-log-file evidencias/t5-serial.txt .
ci: # compilar e simular, como o CI do Lab 11
<<: *esp32
command: sh -c "pio run && wokwi-cli --timeout 10000 --expect-text 'voltas do loop' ."
volumes:
platformio:
4.4 Construir a imagem e compilar no container
docker compose build
docker compose run --rm pio
docker compose run --rm -T pio > evidencias\t4-build-docker.txt 2>&1
type evidencias\t4-build-docker.txt
docker compose buildmonta a imagem a partir doDockerfile(alguns minutos, na primeira vez).- O primeiro
docker compose run --rm piobaixa a plataformaespressif32e o toolchain para Linux (~300 MB, de novo: o do Windows não serve no container) e guarda tudo no volumeplatformio. - O segundo grava a evidência. O
-Tdesliga o terminal interativo, que atrapalha quando a saída vai para um arquivo.
O firmware.bin aparece na sua pasta .pio/build/esp32dev/, porque o container escreve
no bind mount. O build do Windows e o do container usam a mesma .pio/, mas caminhos
diferentes (C:\... × /projeto): na primeira vez que você alternar entre os dois, cada lado
recompila tudo. Um build dentro do container, numa pasta do Windows, também é mais lento que o
do VS Code: é o preço do WSL 2 cruzar os dois sistemas de arquivos.
git add Dockerfile .dockerignore compose.yaml evidencias/t4-docker.txt evidencias/t4-build-docker.txt
git commit -m "T4: build do firmware no Docker"
git push
- ├── 📄Dockerfile👈 Criar Aqui
- ├── 📄.dockerignore👈 Criar Aqui
- ├── 🚀compose.yaml👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t4-docker.txt👈 Criar Aqui
- └── 📄t4-build-docker.txt👈 Criar Aqui
git conferir Dockerfile .dockerignore compose.yaml evidencias/t4-docker.txt evidencias/t4-build-docker.txt
Docker: build no container
git conferir Dockerfile .dockerignore compose.yaml evidencias/t4-docker.txt evidencias/t4-build-docker.txt
git add Dockerfile .dockerignore compose.yaml evidencias/t4-docker.txt evidencias/t4-build-docker.txt && git commit -m "T4: Docker: build no container" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T4.
Projeto integrador — simular no container com o wokwi-cli
O Wokwi do VS Code precisa de alguém olhando a tela. O wokwi-cli roda a mesma simulação
sem interface: envia o firmware.bin e o diagram.json para o simulador do Wokwi (na nuvem),
recebe o monitor serial e termina com um código de saída: 0 se o texto esperado apareceu
no serial a tempo, diferente de 0 se não. É um teste automático do firmware, e é o que o
CI do Lab 11 roda a cada push.
Requisitos
-
Token de CI. Em wokwi.com/dashboard/ci, entre com a sua conta e gere um token. Ele é pessoal: quem tem o token usa a sua cota de simulação.
-
.env, fora do Git. Primeiro, garanta que o Git ignora o.env; depois, crie-o pelo VS Code (Explorer → novo arquivo.env):Terminal do VS Code (cmd)echo .env>> .gitignoregit check-ignore -v .env.env (NÃO vai para o repositório)WOKWI_CLI_TOKEN=cole_aqui_o_seu_tokenO
git check-ignoretem de responder.gitignore:N:.env .env. Odocker composelê o.envsozinho e passa o token ao container pelo${WOKWI_CLI_TOKEN:-}docompose.yaml. Confira comgit status: o.envnão pode aparecer. -
Simular. Com o firmware da T3 já compilado (T4):
Terminal do VS Code (cmd)docker compose run --rm wokwiecho %ERRORLEVEL%Saída (trecho; as mensagens do wokwi-cli variam com a versão)Wokwi CLI v0.x.xStarting simulation...ESP32 inicializado! Lab 02, grupo X[ 2000 ms] LED aceso · 1032915 voltas do loop() em 2 sExpected text found: "voltas do loop"TEST PASSED.0O
--expect-textencerra a simulação assim que o texto aparece; o--timeout 10000é o limite, em milissegundos simulados; o--serial-log-filegrava o serial emevidencias/t5-serial.txt. -
Ver o teste falhar. Rode com um texto que o firmware nunca imprime (o comando depois do nome do serviço substitui o do
compose.yaml):Terminal do VS Code (cmd)docker compose run --rm wokwi wokwi-cli --timeout 5000 --expect-text "texto que nunca aparece" .echo %ERRORLEVEL%O código de saída não é
0. É isso que faz o CI marcar opushem vermelho. -
Tudo de uma vez. O serviço
cicompila e simula na sequência, como o Lab 11 fará:Terminal do VS Code (cmd)docker compose run --rm -T ci > evidencias\t5-wokwi.txt 2>&1echo exit=%ERRORLEVEL%>> evidencias\t5-wokwi.txttype evidencias\t5-wokwi.txtO
echofica numa linha separada de propósito: dentro de parênteses, ocmdtrocaria o%ERRORLEVEL%pelo valor de antes do comando. -
Evidências:
evidencias/t5-wokwi.txt(saída do serviçoci, terminando emexit=0) eevidencias/t5-serial.txt(gravado pelo serviçowokwino passo 3). -
No
README.md: as respostas de P1, P2 e P3.
git status
git add .gitignore evidencias/t5-wokwi.txt evidencias/t5-serial.txt README.md
git commit -m "T5: firmware simulado no Docker com o wokwi-cli"
git push
Nem no compose.yaml, nem no README.md, nem numa evidência. Se ele for parar num commit,
apagar o arquivo depois não resolve: o token continua no histórico. Revogue-o em
wokwi.com/dashboard/ci e gere outro. No Lab 11, ele vai para os secrets do GitHub.
P3: (a) o primeiro docker compose run --rm pio levou minutos, e o segundo, segundos. Se o
container é apagado a cada execução (--rm), onde ficou guardado o toolchain? O que aconteceria
depois de um docker compose down -v? (b) O firmware.bin compilado no container pode ser
simulado pelo Wokwi do VS Code, no Windows? Por quê (pense no bind mount e no que o
firmware.bin contém)? (c) Por que um teste com --expect-text e código de saída serve para o
CI, e um print do monitor serial não serve?
- ├── 📄.gitignore👈 Edite Aqui
- ├── 📂evidencias
- ├── 📄t5-wokwi.txt👈 Criar Aqui
- └── 📄t5-serial.txt👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir .gitignore evidencias/t5-wokwi.txt evidencias/t5-serial.txt README.md
Simulação no container com o wokwi-cli
git conferir .gitignore evidencias/t5-wokwi.txt evidencias/t5-serial.txt README.md
git add .gitignore evidencias/t5-wokwi.txt evidencias/t5-serial.txt README.md && git commit -m "T5: Simulação no container com o wokwi-cli" && 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.
Parte 6 — Placa real (opcional)
Quem tiver um ESP32 DevKit pode gravar o mesmo firmware: o código não muda.
Antes, siga a aba Drivers da configuração do ambiente: a placa tem de aparecer
como uma porta COM no Gerenciador de Dispositivos, e o esptool chip-id tem de responder.
Depois, no terminal do VS Code (a gravação é feita pelo Windows, não pelo container, que não
enxerga as portas COM):
pio device list
pio run -t upload
pio device monitor
O pio device list mostra as portas (COM3, COM4...). O upload compila e grava, e o
monitor abre o serial a 115200 (Ctrl+C sai). Feche o monitor antes de gravar de novo: a
porta COM só atende um programa por vez.
| Problema | O que tentar |
|---|---|
| A porta não aparece | outro cabo (muitos só carregam), outra USB, driver CP210x ou CH340 |
Failed to connect to ESP32 | segure BOOT quando aparecer Connecting.... |
| Caracteres estranhos no serial | monitor_speed diferente do Serial.begin() |
could not open port 'COM4': PermissionError | outro programa está com a porta (um monitor serial aberto, outro terminal): feche-o |
Referência rápida
| Para… | Comando |
|---|---|
| Compilar | pio run |
| Limpar o build | pio run -t clean |
| Simular | F1 → Wokwi: Start Simulator (compile antes) |
| Depurar | F1 → Wokwi: Start Simulator and Wait for Debugger → F5 (Wokwi GDB) |
| Construir a imagem | docker compose build |
| Compilar no container | docker compose run --rm pio |
| Simular no container | docker compose run --rm wokwi |
| Compilar e simular (CI) | docker compose run --rm ci |
| Outro comando na mesma imagem | docker compose run --rm pio <comando> (ex.: pio run -t clean) |
| Gravar a saída num arquivo | docker compose run --rm -T <serviço> > arquivo.txt 2>&1 |
| Código de saída do último comando | echo %ERRORLEVEL% |
| Ver imagens / volumes | docker images · docker volume ls |
| Apagar o cache do PlatformIO | docker compose down -v |
| Fluxo de entrega | ramo → commit Tn: → push → PR → revisão → merge (Lab 01) |
| Atalho do depurador | Ação |
|---|---|
| F9 | liga/desliga o breakpoint na linha |
| F5 | inicia / continua |
| F10 · F11 | próxima linha · entra na função |
| Shift+F5 | encerra a depuração |
| Problema | O que fazer |
|---|---|
'pio' não é reconhecido como um comando interno | ponha %USERPROFILE%\.platformio\penv\Scripts\ no Path (aba PlatformIO) e abra um terminal novo. Se a pasta não existir, o PlatformIO Core ainda não terminou de instalar |
code abre o VS Code sem as extensões | abra no perfil: code --profile "ESP32IO" . |
O primeiro pio run demora muito | é o download do toolchain (~300 MB): deixe terminar. Os builds seguintes levam segundos |
| O Wokwi pede licença | link da aba Wokwi, ou F1 → Wokwi: Request a New License (vence a cada 30 dias) |
firmware.bin not found no Wokwi | compile antes (pio run) e confira os caminhos do wokwi.toml |
| O Wokwi roda o código antigo | ele roda o último build: compile de novo |
Configured debug type 'cppdbg' is not supported | falta a extensão C/C++ (ms-vscode.cpptools) no perfil ESP32IO |
GDB: Unable to start debugging / localhost:3333 | inicie antes o Wokwi: Start Simulator and Wait for Debugger, e confira o gdbServerPort = 3333 no wokwi.toml |
GDB: miDebuggerPath inválido | o caminho do launch.json tem de bater com o dir ...\toolchain-xtensa-esp32\bin\*gdb* (3.2) |
Breakpoint cinza ou variável <optimized out> | build_type = debug no platformio.ini e compile de novo |
docker: error during connect | o Docker Desktop está fechado ou iniciando: abra-o e espere |
'docker' não é reconhecido como um comando interno | o Docker Desktop terminou de instalar depois que o VS Code abriu: feche e abra o VS Code |
docker compose build falha no curl do wokwi-cli | sem acesso ao GitHub (proxy ou rede): tente de novo em outra rede |
no configuration file provided: not found | rode o docker compose na raiz do repositório, onde está o compose.yaml |
wokwi-cli: token ausente ou inválido | falta o .env na raiz, com WOKWI_CLI_TOKEN=... sem espaços nem aspas; ou o token foi revogado |
wokwi-cli: firmware.bin não encontrado | compile antes: docker compose run --rm pio (ou use o serviço ci) |
wokwi-cli termina por timeout | o texto do --expect-text não apareceu no serial: confira o firmware gravado (é o da T3?) e as maiúsculas |
| Build no container muito lento | é a pasta do Windows vista pelo WSL 2; o segundo build, com o cache, é bem mais rápido |
| O terminal abre como PowerShell | falta o .vscode/settings.json (Lab 01, 1.1): crie-o e abra um terminal novo |
Logout do seu ambiente dev, git e gh
Para o git "esquecer" suas informações salvas:
git credential-manager erase && cmdkey /list | findstr "github" && gh auth logout
Antes de sair, faça logout para não deixar sua conta do GitHub ativa nesta máquina. Rode os comandos abaixo no Prompt de Comando (cmd), não no PowerShell.
1. Apague a credencial do GitHub salva pelo git, encerre a sessão do gh e remova seu nome e e-mail da configuração global:
(echo protocol=https&echo host=github.com) | git credential reject
gh auth logout --hostname github.com
git config --global --unset user.name
git config --global --unset user.email
Para conferir, este comando não deve mostrar nada:
cmdkey /list | findstr /i github
2. Pare os containers do lab:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
3. No navegador, saia da sua conta em github.com e feche todas as janelas.