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 com plataforma e bibliotecas em versões fixas, 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 10 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 reprodutível: plataforma e bibliotecas com versão fixa.
- 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 10, o mesmo simulador roda sem interface, dentro do CI, com as mesmas ferramentas e nas mesmas
versões que a imagem que você monta hoje.
Clonar o repositório do grupo
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
- Grupo: Grupo-A (slug:
grupo-a) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-a
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-a/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-b
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-b/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-c
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-c/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-d
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-d/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-e
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-e/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-f
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-f/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-g
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-g/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-h
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-h/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-i
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-i/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-j
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-j/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-k
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-k/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-l
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-l/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-m
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-m/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-x
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-x/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-p
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-p/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab02-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT73A-S22-2026-2/lab02-grupo-n
- Commits: https://github.com/ELT73A-S22-2026-2/lab02-grupo-n/commits/main/
- Acessos: ACESSO-LAB02.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\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 com versoes fixas · 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 com versões fixas
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 Fixar as versões
O pio project init escreve platform = espressif32, sem versão. Sem versão, o mesmo projeto
compila com um core Arduino diferente quando sai uma versão nova, e um código que funcionava
para de compilar "sozinho". Fixe:
[env:esp32dev]
platform = espressif32@6.9.0 ; versão fixa: core Arduino 2.0.17 (o dos labs seguintes)
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@6.9.0, 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 10 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 com versões fixas"
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 com versoes fixas
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 com versoes fixas" && 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": "elt73a - 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):
# elt73a - ambiente de build e simulação do ESP32 (as mesmas versões do CI do Lab 10)
FROM python:3.12-slim
# Versão fixa do PlatformIO Core, como a plataforma no platformio.ini
ARG PIO_VERSION=6.2.0
# Versão fixa do wokwi-cli (a mesma do Lab 10)
ARG WOKWI_CLI_VERSION=v0.28.1
# 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==${PIO_VERSION}"
# 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/download/${WOKWI_CLI_VERSION}/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.
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: elt73a/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 10
<<: *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 plataformaespressif32@6.9.0e 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 10 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 10 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 10, 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
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.