Laboratório 03
Checklist — logs no ESP32 e ambientes de build (debug × release)
- Os cinco níveis de log (
log_e…log_v) aparecendo no Wokwi comCORE_DEBUG_LEVEL=5(T1) - O mesmo código com
CORE_DEBUG_LEVEL=2, e a prova de que as mensagens saíram do binário (T2) -
platformio.inicom dois ambientes,debugerelease, compilando os dois (T3) - Logs com dados formatados, falhas, taxa de erro e hexdump, sem
delay()(T4) - Firmware com relatório de boot, nos dois ambientes, com as evidências (T5)
- Previsões P1–P3 respondidas no
README.md - Nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
T1…T5 = 100 pts (esta aula não tem desafios): T1 15 · T2 20 · T3 20 · T4 20 · T5 25. O
autograder normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.
Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):
Verificação rápida das versões instaladas:
git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version
Verificação rápida de autenticação e alias:
git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"
Adicionar o comando git conferir:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Configuração do ambiente de desenvolvimento
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
Até aqui, o firmware falava com você por Serial.println(). Funciona, mas não escala: um erro
grave e um detalhe sem importância saem iguais, não se sabe de que arquivo veio cada linha, e
os print de depuração ficam no produto, a não ser que alguém se lembre de apagá-los.
O core Arduino do ESP32 tem um sistema de log com cinco níveis. Cada mensagem sai com o
instante, o nível, o arquivo, a linha e a função. E o mais importante: o nível é escolhido
na compilação. As mensagens abaixo do nível escolhido não são escondidas, elas deixam de
existir no firmware. Com dois ambientes no platformio.ini, o mesmo código vira um
firmware de desenvolvimento, falante, e um de produto, que só registra erros.
Os labs seguintes usam os logs o tempo todo: o Lab 04 mostra, com eles, o que o Wi-Fi e o MQTT estão fazendo por dentro.
Objetivos
- Usar as macros
log_e,log_w,log_i,log_delog_v, com formatação estiloprintf. - Entender o
CORE_DEBUG_LEVEL: o filtro acontece na compilação, não na execução. - Provar que as mensagens filtradas saíram do binário.
- Criar ambientes
debugereleasenoplatformio.inie escolher qual compilar. - Usar o log para contar uma história: falha, recuperação, estatística e dump de bytes.
Material
- O ambiente dos Labs 01 e 02: Windows 11, VS Code no perfil
ESP32IOcom o terminal no Prompt de Comando (cmd), PlatformIO com opiono Path e o Wokwi com licença ativa. - Nenhuma placa: tudo roda no Wokwi.
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/lab03-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-a/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-a.git && cd lab03-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-b/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-b.git && cd lab03-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-c/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-c.git && cd lab03-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-d/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-d.git && cd lab03-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-e/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-e.git && cd lab03-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-f/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-f.git && cd lab03-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-g/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-g.git && cd lab03-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-h/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-h.git && cd lab03-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-i/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-i.git && cd lab03-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-j/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-j.git && cd lab03-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-k/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-k.git && cd lab03-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-l/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-l.git && cd lab03-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-m/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-m.git && cd lab03-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-x/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-x.git && cd lab03-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-p/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-p.git && cd lab03-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab03-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab03-grupo-n/commits/main/
- Acessos: ACESSO-LAB03.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/lab03-grupo-n.git && cd lab03-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab03-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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 03:
- 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 — Os cinco níveis de log · 15 pts
- T2 — Filtrar na compilação · 20 pts
- T3 — Ambientes debug e release · 20 pts
- T4 — Logs com dados e falhas · 20 pts
- T5 — Firmware com relatório de boot · 25 pts
O repositório nasce do lab03-template, com o README.md, o .gitignore e o
.vscode/settings.json (terminal cmd):
Estrutura de Arquivos do Projeto (no fim da aula)
- ├── 📄.gitignore👈 Verificar
- ├── 📂.vscode
- └── 🔧settings.json👈 Verificar
- ├── 📝README.md👈 Edite Aqui
- ├── 🔧platformio.ini👈 Criar Aqui
- ├── 📂src
- └── 📄main.cpp👈 Criar Aqui
- ├── 🔧diagram.json👈 Criar Aqui
- ├── 🔧wokwi.toml👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t1-serial.txt👈 Criar Aqui
- ├── 📄t2-nivel5.txt👈 Criar Aqui
- ├── 📄t2-nivel2.txt👈 Criar Aqui
- ├── 📄t3-ambientes.txt👈 Criar Aqui
- ├── 📄t4-serial.txt👈 Criar Aqui
- ├── 📄t5-serial.txt👈 Criar Aqui
- └── 📄t5-build.txt👈 Criar Aqui
Como a correção funciona
O autograder roda no GitHub a cada push. Para cada tarefa, ele acha o commit Tn: mais
recente, volta o repositório àquele ponto e confere duas coisas: se o projeto compila
(pio run) e se os requisitos da tarefa estão lá (as macros, o CORE_DEBUG_LEVEL pedido, os
ambientes, as evidências). A nota de cada tarefa é proporcional às verificações que passam, e
o resumo aparece na aba Actions do repositório.
Por isso cada tarefa é um commit: a T2 pede CORE_DEBUG_LEVEL=2 e a T3 volta a subir o
nível. Sem o commit T2:, não haveria como corrigir a T2.
Parte 1 — Os cinco níveis
1.1 Projeto e circuito
Abra o repositório no perfil da disciplina (code --profile "ESP32IO" .) e, no terminal do VS
Code (cmd), crie o projeto:
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200"
if not exist evidencias mkdir evidencias
O circuito é o do Lab 02: o LED com resistor no GPIO2. Copie o diagram.json do Lab 02 (ou
crie-o de novo) e o wokwi.toml:
diagram.json e wokwi.toml (iguais aos do Lab 02)
{
"version": 1,
"author": "ELT85B - Lab 03",
"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": {}
}
[wokwi]
version = 1
firmware = '.pio/build/esp32dev/firmware.bin'
elf = '.pio/build/esp32dev/firmware.elf'
1.2 Ligar todos os níveis
O nível de log é uma macro do pré-processador, passada ao compilador pelo build_flags:
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
build_flags =
-DCORE_DEBUG_LEVEL=5 ; 0 nada · 1 E · 2 W · 3 I · 4 D · 5 V
| Macro | Nível | Valor | Quando usar |
|---|---|---|---|
log_e() | Error | 1 | falhas que impedem a operação (o sensor não responde) |
log_w() | Warning | 2 | algo estranho, mas o programa segue (valor fora da faixa) |
log_i() | Info | 3 | marcos normais ("Wi-Fi conectado") |
log_d() | Debug | 4 | detalhes úteis durante o desenvolvimento |
log_v() | Verbose | 5 | tudo, inclusive valores brutos e laços internos |
Uma macro só gera código se o seu valor for menor ou igual ao CORE_DEBUG_LEVEL.
#include <Arduino.h>
#define LED_PIN 2
int chamadas = 0; // quantas vezes medir() rodou
int medir() { // uma "medida" com efeito colateral
chamadas++;
return 42;
}
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
Serial.println("=== Lab 03 - logs no ESP32 ===");
log_e("Isto e um ERRO (log_e)");
log_w("Isto e um AVISO (log_w)");
log_i("Isto e uma INFO (log_i): LED no GPIO %d", LED_PIN);
log_d("Isto e DEBUG (log_d): medida = %d", medir());
log_v("Isto e VERBOSE (log_v)");
Serial.printf("Nivel de log compilado = %d; medir() rodou %d vez(es)\r\n", ARDUHAL_LOG_LEVEL, chamadas);
}
void loop() {}
O ARDUHAL_LOG_LEVEL é o nível que o core realmente usou: o CORE_DEBUG_LEVEL, se ele foi
definido, ou um padrão, se não foi (P1).
1.3 Compilar e simular
pio run
F1 → Wokwi: Start Simulator:
[ 239][D][esp32-hal-cpu.c:244] setCpuFrequencyMhz(): PLL: 480 / 2 = 240 Mhz, APB: 80000000 Hz
[ 371][V][esp32-hal-uart.c:330] uartBegin(): UART0 baud(115200) Mode(800001c) rxPin(3) txPin(1)
[ 375][V][esp32-hal-uart.c:416] uartBegin(): UART0 not installed. Starting installation
[ 381][V][esp32-hal-uart.c:463] uartBegin(): UART0 initialization done.
=== Lab 03 - logs no ESP32 ===
[ 385][E][main.cpp:18] setup(): Isto e um ERRO (log_e)
[ 386][W][main.cpp:19] setup(): Isto e um AVISO (log_w)
[ 386][I][main.cpp:20] setup(): Isto e uma INFO (log_i): LED no GPIO 2
[ 387][D][main.cpp:21] setup(): Isto e DEBUG (log_d): medida = 42
[ 387][V][main.cpp:22] setup(): Isto e VERBOSE (log_v)
Nivel de log compilado = 5; medir() rodou 1 vez(es)
Uma linha de log, da esquerda para a direita:
| Trecho | Significado |
|---|---|
[ 385] | milissegundos desde o boot |
[E] | o nível (E, W, I, D ou V) |
[main.cpp:18] | arquivo e linha de onde a mensagem saiu |
setup(): | a função que chamou |
Isto e um ERRO... | a sua mensagem |
As quatro primeiras linhas não são suas: o próprio core usa os mesmos logs (a CPU a
240 MHz, a UART sendo configurada pelo Serial.begin). Com o nível 5, você vê também o que as
bibliotecas fazem por dentro.
As macros aceitam os especificadores do printf: %d (inteiro), %u (sem sinal), %lu
(unsigned long), %.1f (float com uma casa), %s (texto), %x (hexadecimal) e %% (o
próprio %).
Copie o monitor serial para evidencias/t1-serial.txt.
P1: (a) apague as duas linhas do build_flags e compile de novo. Quantas linhas [E],
[W], [I]... aparecem? Que número o Nivel de log compilado mostra? (Dica: o PlatformIO não
define o CORE_DEBUG_LEVEL, e o core usa um valor padrão. A Arduino IDE define, com o valor do
menu Core Debug Level.) (b) Por que a linha Serial.printf aparece em qualquer nível?
Volte o build_flags para 5 antes do commit.
git add platformio.ini src diagram.json wokwi.toml evidencias/t1-serial.txt
git commit -m "T1: os cinco niveis de log"
git push
- ├── 🔧platformio.ini👈 Criar Aqui
- ├── 📂src
- └── 📄main.cpp👈 Criar Aqui
- ├── 🔧diagram.json👈 Criar Aqui
- ├── 🔧wokwi.toml👈 Criar Aqui
- └── 📂evidencias
- └── 📄t1-serial.txt👈 Criar Aqui
git conferir platformio.ini src/main.cpp diagram.json wokwi.toml evidencias/t1-serial.txt
Os cinco níveis de log
git conferir platformio.ini src/main.cpp diagram.json wokwi.toml evidencias/t1-serial.txt
git add platformio.ini src/main.cpp diagram.json wokwi.toml evidencias/t1-serial.txt && git commit -m "T1: Os cinco níveis de log" && 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 — Filtrar na compilação
Antes de mudar o nível, registre o firmware atual (nível 5). O pio run grava o tamanho, e o
findstr /m procura um texto dentro do binário: se achar, imprime o nome do arquivo; se
não achar, não imprime nada.
pio run > evidencias\t2-nivel5.txt 2>&1
findstr /m /c:"Isto e DEBUG" .pio\build\esp32dev\firmware.bin >> evidencias\t2-nivel5.txt
type evidencias\t2-nivel5.txt
Agora, sem mudar o código, troque o nível no platformio.ini:
build_flags =
-DCORE_DEBUG_LEVEL=2
pio run > evidencias\t2-nivel2.txt 2>&1
findstr /m /c:"Isto e DEBUG" .pio\build\esp32dev\firmware.bin >> evidencias\t2-nivel2.txt
type evidencias\t2-nivel2.txt
Simule:
=== Lab 03 - logs no ESP32 ===
[ 341][E][main.cpp:18] setup(): Isto e um ERRO (log_e)
[ 344][W][main.cpp:19] setup(): Isto e um AVISO (log_w)
Nivel de log compilado = 2; medir() rodou 0 vez(es)
Compare os dois arquivos de evidência:
| Nível 5 | Nível 2 | |
|---|---|---|
| Linhas no monitor | as 5 suas + as do core | só [E] e [W] |
findstr acha Isto e DEBUG no .bin? | sim (imprime o nome do arquivo) | não (linha vazia) |
Tamanho do firmware (linha Flash:) | maior | ~2,4 KB menor |
medir() rodou | 1 vez | 0 vez |
As linhas de Info, Debug e Verbose não foram filtradas na hora de imprimir: no nível 2, o
pré-processador troca log_d(...) por um comando vazio, e o texto nem chega ao firmware.
P2: (a) por que o medir() deixou de rodar no nível 2, se a linha log_d(..., medir())
continua no código? O que aconteceria num firmware que fizesse log_d("lido: %d", fila.retira())? (b) Por que o filtro na compilação é melhor que um if (nivel <= X) dentro do
código, em memória e em tempo de CPU?
O commit da T2 fica com o nível 2: é o que o autograder confere.
git add platformio.ini evidencias/t2-nivel5.txt evidencias/t2-nivel2.txt
git commit -m "T2: filtra os logs com CORE_DEBUG_LEVEL=2"
git push
- ├── 🔧platformio.ini👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t2-nivel5.txt👈 Criar Aqui
- └── 📄t2-nivel2.txt👈 Criar Aqui
git conferir platformio.ini evidencias/t2-nivel5.txt evidencias/t2-nivel2.txt
Filtrar na compilação
git conferir platformio.ini evidencias/t2-nivel5.txt evidencias/t2-nivel2.txt
git add platformio.ini evidencias/t2-nivel5.txt evidencias/t2-nivel2.txt && git commit -m "T2: Filtrar na compilação" && 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 — Ambientes debug e release
Trocar o nível na mão a cada build é fácil de esquecer. O PlatformIO permite vários
ambientes ([env:nome]) no mesmo platformio.ini: o que for comum fica no [env], e cada
ambiente acrescenta o que é dele.
[platformio]
default_envs = debug ; o "pio run" sem -e compila só este
[env] ; comum a todos os ambientes
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
[env:debug] ; desenvolvimento: logs até DEBUG
build_flags =
-DCORE_DEBUG_LEVEL=4
-DMODO_DEBUG
[env:release] ; produto: só os erros
build_flags =
-DCORE_DEBUG_LEVEL=1
O default_envs fica na seção [platformio], e não no [env]: é uma opção do projeto,
não do build. O -DMODO_DEBUG é uma macro sua, que o código pode testar:
#ifdef MODO_DEBUG
Serial.printf("Firmware de DEBUG (CORE_DEBUG_LEVEL=%d)\r\n", CORE_DEBUG_LEVEL);
#else
Serial.printf("Firmware de RELEASE (CORE_DEBUG_LEVEL=%d)\r\n", CORE_DEBUG_LEVEL);
#endif
Cada ambiente compila numa pasta própria, .pio\build\<ambiente>\. O Wokwi precisa saber
qual delas rodar:
[wokwi]
version = 1
firmware = '.pio/build/debug/firmware.bin'
elf = '.pio/build/debug/firmware.elf'
Compile os dois ambientes de uma vez e confira o resumo no fim:
pio run -e debug -e release > evidencias\t3-ambientes.txt 2>&1
type evidencias\t3-ambientes.txt
Environment Status Duration
------------- -------- ------------
debug SUCCESS 00:00:05.123
release SUCCESS 00:00:04.876
========================= 2 succeeded in 00:00:10.000 =========================
Simule (roda o debug) e confira o título Firmware de DEBUG (CORE_DEBUG_LEVEL=4).
| Comando | O que compila |
|---|---|
pio run | só o default_envs (debug) |
pio run -e release | só o release |
pio run -e debug -e release | os dois |
pio run -t clean -e release | apaga o build do release |
O wokwi.toml aponta para um ambiente só. Para ver o release no Wokwi, troque debug por
release nos dois caminhos, compile o release e inicie o simulador. Volte para debug antes
do commit.
git add platformio.ini src/main.cpp wokwi.toml evidencias/t3-ambientes.txt
git commit -m "T3: ambientes debug e release"
git push
- ├── 🔧platformio.ini👈 Edite Aqui
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- ├── 🔧wokwi.toml👈 Edite Aqui
- └── 📂evidencias
- └── 📄t3-ambientes.txt👈 Criar Aqui
git conferir platformio.ini src/main.cpp wokwi.toml evidencias/t3-ambientes.txt
Ambientes debug e release
git conferir platformio.ini src/main.cpp wokwi.toml evidencias/t3-ambientes.txt
git add platformio.ini src/main.cpp wokwi.toml evidencias/t3-ambientes.txt && git commit -m "T3: Ambientes debug e release" && 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 — Logs com dados e falhas
Um "sensor" simulado: uma leitura por segundo, que falha a cada quatro. Os níveis contam a
história: o log_e marca a falha exata, o log_w mostra a recuperação, o log_i o
funcionamento normal e o log_v o detalhe que só interessa às vezes. Tudo com millis(), sem
delay() (Lab 02).
Acrescente ao main.cpp (antes do setup()):
#define LEITURA_MS 1000 // ms: uma leitura do "sensor" por segundo
#define LIMITE_C 30.0f // acima disto, aviso
uint32_t leituras = 0, falhas = 0;
float ultimoValor = NAN;
bool lerSensor(float *saida) {
static uint32_t tentativa = 0;
tentativa++;
if (tentativa % 4 == 0) { // a cada 4 leituras, uma "falha"
log_e("Falha ao ler o sensor (tentativa %lu)", (unsigned long)tentativa);
return false;
}
*saida = 20.0f + (tentativa % 15); // valor fake que varia de 20 a 34
log_v("Sensor respondeu na tentativa %lu", (unsigned long)tentativa);
return true;
}
void tarefaSensor() {
float t;
leituras++;
if (lerSensor(&t)) {
ultimoValor = t;
if (t > LIMITE_C) log_w("Temperatura alta: %.1f C (limite %.0f)", t, LIMITE_C);
else log_i("Temperatura: %.1f C", t);
} else {
falhas++;
log_w("Leitura ignorada; ultimo valor valido: %.1f C", ultimoValor);
}
if (leituras % 10 == 0) {
log_i("Taxa de falhas: %lu de %lu = %.1f%%", (unsigned long)falhas, (unsigned long)leituras,
100.0f * falhas / leituras);
// o "pacote" que iria pela rede: cabeçalho, temperatura em décimos, contadores, checksum
uint16_t decimos = (uint16_t)(ultimoValor * 10);
uint8_t pacote[8] = {0xA5, 0x03, (uint8_t)(decimos >> 8), (uint8_t)decimos,
(uint8_t)(leituras >> 8), (uint8_t)leituras, (uint8_t)falhas, 0};
for (int i = 0; i < 7; i++) pacote[7] ^= pacote[i];
log_buf_i(pacote, sizeof(pacote));
}
}
unsigned long tLed = 0, tLeitura = 0;
bool ledAceso = false;
E troque o loop():
void loop() {
unsigned long agora = millis();
if (agora - tLed >= 500) { // pisca, como no Lab 02
tLed += 500;
ledAceso = !ledAceso;
digitalWrite(LED_PIN, ledAceso ? HIGH : LOW);
log_v("LED %s", ledAceso ? "aceso" : "apagado");
}
if (agora - tLeitura >= LEITURA_MS) {
tLeitura += LEITURA_MS;
tarefaSensor();
}
}
[ 3000][I][main.cpp:78] tarefaSensor(): Temperatura: 23.0 C
[ 4000][E][main.cpp:64] lerSensor(): Falha ao ler o sensor (tentativa 4)
[ 4001][W][main.cpp:81] tarefaSensor(): Leitura ignorada; ultimo valor valido: 23.0 C
...
[ 9000][I][main.cpp:78] tarefaSensor(): Temperatura: 29.0 C
[ 10000][I][main.cpp:78] tarefaSensor(): Temperatura: 30.0 C
[ 10000][I][main.cpp:86] tarefaSensor(): Taxa de falhas: 2 de 10 = 20.0%
0xa5, 0x03, 0x01, 0x2c, 0x00, 0x0a, 0x02, 0x83, // ...,....
[ 11000][W][main.cpp:77] tarefaSensor(): Temperatura alta: 31.0 C (limite 30)
O log_buf_i imprime os bytes em hexadecimal e, depois do //, os que são texto (os outros
viram .). Ele não tem o prefixo [I][arquivo:linha]. Confira o pacote: 0x01, 0x2c é
300, ou 30,0 °C em décimos; 0x00, 0x0a são 10 leituras; 0x02, 2 falhas.
Os log_v (o LED e o sensor que respondeu) não aparecem: o debug vai até o nível 4.
P3: (a) a 115200 baud, cada caractere leva 10 bits na UART. Quanto tempo leva uma linha de
log de 80 caracteres? O log_printf do core espera a UART terminar de enviar antes de
voltar. O que aconteceria com um log_d dentro de um laço que precisa rodar a cada 1 ms? (b)
Por que o pisca do LED usa log_v, e não log_d? (c) Por que o release mantém o nível 1,
e não 0?
Copie pelo menos 12 s do monitor (com uma linha de taxa e o hexdump) para
evidencias/t4-serial.txt.
git add src/main.cpp evidencias/t4-serial.txt
git commit -m "T4: logs com dados e falhas"
git push
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- └── 📂evidencias
- └── 📄t4-serial.txt👈 Criar Aqui
git conferir src/main.cpp evidencias/t4-serial.txt
Logs com dados e falhas
git conferir src/main.cpp evidencias/t4-serial.txt
git add src/main.cpp evidencias/t4-serial.txt && git commit -m "T4: Logs com dados e falhas" && 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 — firmware com relatório de boot
Todo firmware de produto deveria dizer, ao ligar, em que está rodando e por que reiniciou. Um reset por watchdog ou por queda de tensão é a primeira pista de um defeito no campo, e só aparece se o firmware registrar.
Requisitos
-
relatorioBoot(), chamado no fim dosetup(), com:- modelo do chip, revisão, número de núcleos e frequência da CPU (
log_i); - tamanho da flash e heap livre agora e o mínimo desde o boot (
log_i); - versão do ESP-IDF por baixo do core Arduino (
log_d); - motivo do último reset:
log_ise foi o normal (ligar ou o botão EN),log_wse foi qualquer outro (watchdog, pânico, queda de tensão...).
src/main.cpp (T5)#include <esp_system.h> // esp_reset_reason()const char *nomeReset(esp_reset_reason_t r) {switch (r) {case ESP_RST_POWERON: return "liga/desliga (POWERON)";case ESP_RST_EXT: return "pino EN (EXT)";case ESP_RST_SW: return "por software (SW)";case ESP_RST_PANIC: return "panico/excecao (PANIC)";case ESP_RST_INT_WDT: return "watchdog de interrupcao (INT_WDT)";case ESP_RST_TASK_WDT: return "watchdog de tarefa (TASK_WDT)";case ESP_RST_WDT: return "outro watchdog (WDT)";case ESP_RST_BROWNOUT: return "queda de tensao (BROWNOUT)";case ESP_RST_DEEPSLEEP:return "saida do deep sleep (DEEPSLEEP)";default: return "desconhecido";}}void relatorioBoot() {log_i("Chip %s rev %d, %d nucleo(s) a %lu MHz", ESP.getChipModel(), ESP.getChipRevision(),ESP.getChipCores(), (unsigned long)ESP.getCpuFreqMHz());log_i("Flash %lu KB", (unsigned long)(ESP.getFlashChipSize() / 1024));log_i("Heap livre %lu bytes (menor desde o boot: %lu)", (unsigned long)ESP.getFreeHeap(),(unsigned long)ESP.getMinFreeHeap());log_d("ESP-IDF %s", ESP.getSdkVersion());esp_reset_reason_t r = esp_reset_reason();if (r == ESP_RST_POWERON || r == ESP_RST_EXT) log_i("Reset: %s", nomeReset(r));else log_w("Reset inesperado: %s", nomeReset(r));} - modelo do chip, revisão, número de núcleos e frequência da CPU (
-
Organização: o código da T1 (os cinco níveis e o
medir()) vai para uma funçãocincoNiveis(), chamada nosetup(). Osetup()fica:Serial.begin,pinMode, título,#ifdef MODO_DEBUG,cincoNiveis(),relatorioBoot(). -
Os dois ambientes compilam, e o
releasenão tem as mensagens de debug:Terminal do VS Code (cmd)pio run -e debug -e release > evidencias\t5-build.txt 2>&1echo == "Isto e DEBUG" no debug: >> evidencias\t5-build.txtfindstr /m /c:"Isto e DEBUG" .pio\build\debug\firmware.bin >> evidencias\t5-build.txtecho == "Isto e DEBUG" no release: >> evidencias\t5-build.txtfindstr /m /c:"Isto e DEBUG" .pio\build\release\firmware.bin >> evidencias\t5-build.txttype evidencias\t5-build.txt -
Simulação do
debug, com pelo menos 12 s, emevidencias/t5-serial.txt:Monitor serial do Wokwi (debug, início; valores e números de linha variam)[ 145][D][esp32-hal-cpu.c:244] setCpuFrequencyMhz(): PLL: 480 / 2 = 240 Mhz, APB: 80000000 Hz=== Lab 03 - logs no ESP32 ===Firmware de DEBUG (CORE_DEBUG_LEVEL=4)[ 263][E][main.cpp:19] cincoNiveis(): Isto e um ERRO (log_e)[ 265][W][main.cpp:20] cincoNiveis(): Isto e um AVISO (log_w)[ 265][I][main.cpp:21] cincoNiveis(): Isto e uma INFO (log_i): LED no GPIO 2[ 266][D][main.cpp:22] cincoNiveis(): Isto e DEBUG (log_d): medida = 42Nivel de log compilado = 4; medir() rodou 1 vez(es)[ 266][I][main.cpp:45] relatorioBoot(): Chip ESP32-D0WDQ6 rev 0, 2 nucleo(s) a 240 MHz[ 268][I][main.cpp:46] relatorioBoot(): Flash 4096 KB[ 268][I][main.cpp:48] relatorioBoot(): Heap livre 351452 bytes (menor desde o boot: 346320)[ 269][D][main.cpp:49] relatorioBoot(): ESP-IDF v4.4.7-dirty[ 269][I][main.cpp:52] relatorioBoot(): Reset: liga/desliga (POWERON)[ 1001][I][main.cpp:78] tarefaSensor(): Temperatura: 21.0 CE o
release, para comparar (troque owokwi.tomlcomo na nota da Parte 3):Monitor serial do Wokwi (release)=== Lab 03 - logs no ESP32 ===Firmware de RELEASE (CORE_DEBUG_LEVEL=1)[ 263][E][main.cpp:19] cincoNiveis(): Isto e um ERRO (log_e)Nivel de log compilado = 1; medir() rodou 0 vez(es)[ 4008][E][main.cpp:64] lerSensor(): Falha ao ler o sensor (tentativa 4)[ 8003][E][main.cpp:64] lerSensor(): Falha ao ler o sensor (tentativa 8) -
No
README.md: as respostas de P1, P2 e P3, e uma tabela com o tamanho do firmware (linhaFlash:) nos ambientesdebugerelease.
git add src/main.cpp wokwi.toml evidencias/t5-serial.txt evidencias/t5-build.txt README.md
git commit -m "T5: relatorio de boot"
git push
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- ├── 🔧wokwi.toml👈 Edite Aqui
- ├── 📂evidencias
- ├── 📄t5-serial.txt👈 Criar Aqui
- └── 📄t5-build.txt👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir src/main.cpp wokwi.toml evidencias/t5-serial.txt evidencias/t5-build.txt README.md
Firmware com relatório de boot
git conferir src/main.cpp wokwi.toml evidencias/t5-serial.txt evidencias/t5-build.txt README.md
git add src/main.cpp wokwi.toml evidencias/t5-serial.txt evidencias/t5-build.txt README.md && git commit -m "T5: Firmware com relatório de boot" && 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.
Referência rápida
| Macro | Aparece se CORE_DEBUG_LEVEL ≥ | Uso típico |
|---|---|---|
log_e("...", ...) | 1 | erro |
log_w("...", ...) | 2 | aviso |
log_i("...", ...) | 3 | informação |
log_d("...", ...) | 4 | depuração |
log_v("...", ...) | 5 | detalhe fino |
log_buf_i(buf, tam) | 3 | dump hexadecimal (também log_buf_e, _w, _d, _v) |
| Para… | Comando ou configuração |
|---|---|
| Escolher o nível | build_flags = -DCORE_DEBUG_LEVEL=<0..5> |
| Compilar um ambiente | pio run -e release |
Compilar todos os do default_envs | pio run |
| Procurar um texto no firmware | findstr /m /c:"texto" .pio\build\debug\firmware.bin |
| Gravar a saída e os erros de um comando | comando > arquivo.txt 2>&1 (e >> para acrescentar) |
| Ver um arquivo | type arquivo.txt |
| Sintoma | Causa provável | O que fazer |
|---|---|---|
Só aparecem os log_e | CORE_DEBUG_LEVEL não definido: o padrão do core é 1 (P1) | defina o nível no build_flags e recompile |
| Só aparecem erros e avisos | nível 1 ou 2 | suba o CORE_DEBUG_LEVEL |
| O Wokwi mostra o firmware antigo | simulou sem recompilar, ou o wokwi.toml aponta para outro ambiente | compile o ambiente certo e confira os caminhos |
firmware.bin not found | o wokwi.toml ainda aponta para esp32dev depois da T3 | troque para .pio/build/debug/ |
| Caracteres estranhos | monitor_speed diferente do Serial.begin() | os dois em 115200 |
%f imprime algo estranho | passou um int para %f, ou um float para %d | confira o tipo de cada argumento |
'pio' não é reconhecido... | falta o Path (aba PlatformIO) | veja a configuração do ambiente |
Mais sobre o core e a plataforma: arduino-esp32, PlatformIO — Espressif 32 e a referência da linguagem Arduino.
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.