Laboratório 03
Checklist — PlatformIO IDE e Logging no ESP32
- Projeto PlatformIO criado e compilando (T1)
- Logs nativos (
log_e…log_v) e pisca do LED commillis()(T2) -
CORE_DEBUG_LEVELnoplatformio.ini, com plataforma em versão fixa (T3) -
wokwi.toml+diagram.jsone o firmware simulado, com os logs no monitor serial (T4) - Contador de erros com a taxa de falhas em
%.1f%%(T5) - Nível de produção (
CORE_DEBUG_LEVEL=1) explicado noREADME.md(T6) - Hexdump de um buffer com
log_buf_i()(T7) - Desafio: pisca do LED com um
log_da cada troca de estado (T8) - Workflow de CI compilando o firmware a cada
push(T9) - Nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
T1…T9 = 100 pts (esta aula não tem desafios valendo extra): T1 5 · T2 10 · T3 10 · T4 20 ·
T5 10 · T6 10 · T7 10 · T8 10 · T9 15. 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
Clonar o repositório do grupo
Escolha o grupo e rode o comando gerado para criar o repositório no GitHub:
- 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/lab03-grupo-a
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-a/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-b
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-b/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-c
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-c/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-d
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-d/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-e
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-e/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-f
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-f/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-g
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-g/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-h
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-h/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-i
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-i/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-j
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-j/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-k
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-k/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-l
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-l/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-m
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-m/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-x
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-x/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-p
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-p/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT73A-S22-2026-2/lab03-grupo-n
- Commits: https://github.com/ELT73A-S22-2026-2/lab03-grupo-n/commits/main/
- Acessos: ACESSO-LAB03.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/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%\ELT73AS22\lab03-grupo-n" && code . --profile "ESP32IO"
Estrutura organizacional dos repositórios
ELT73A-S22-2026-2
├── Times
│ ├── Grupo-A
│ ├── ...
│ ├── Grupo-P # (Professor)
│ └── Grupo-N # (Notas)
└── Repositórios
├── lab03-template
├── lab03-grupo-a
├── ...
├── lab03-grupo-p # (Professor)
└── lab03-grupo-n # (Notas)
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 — 9 tarefas · 100 pts
- T1 — Projeto PlatformIO · 5 pts
- T2 — Logs e pisca do LED · 10 pts
- T3 — CORE_DEBUG_LEVEL no platformio.ini · 10 pts
- T4 — Wokwi no VS Code · 20 pts
- T5 — Contador de erros · 10 pts
- T6 — Nivel de producao · 10 pts
- T7 — Hexdump · 10 pts
- T8 — Desafio: pisca com log_d · 10 pts
- T9 — CI no GitHub Actions · 15 pts
Avaliação do laboratório — como é corrigido
A avaliação é automática e roda no GitHub a cada push. A ideia é simples:
A mensagem do commit começa com o código da tarefa (T1, T2, ...). O robô de correção encontra o commit de cada tarefa, volta o repositório para aquele ponto exato da história e testa se os requisitos daquela tarefa foram cumpridos.
Você acompanha a nota na aba Actions do seu repositório (resumo do job) e no
arquivo GRADE.md, disponível em Artifacts de cada execução.
Convenção de commits (obrigatória)
Ao terminar uma tarefa, faça um commit cuja mensagem comece com o código dela:
git add .
git commit -m "T1: implementa os cinco niveis de log"
git push
Regras:
- O código vai no início da mensagem:
T1,T2, ... seguido de:e uma descrição. - Pode refazer uma tarefa: basta um novo commit
T1: .... O corretor usa sempre o commit mais recente de cada código. T1eT10são tarefas diferentes — o corretor não confunde uma com a outra.- Uma tarefa sem commit correspondente vale zero.
Cada commit funciona como um carimbo com data/hora da entrega: serve de prova
do seu progresso e permite corrigir tarefas que editam o mesmo arquivo (por
exemplo, mudar CORE_DEBUG_LEVEL de 5 para 2 e depois voltar para 5).
O que é verificado em cada tarefa
O corretor faz, para cada tarefa, no estado do repositório naquele commit:
- Compilação — o projeto precisa compilar com
pio run(código quebrado não pontua nessa verificação). - Requisitos específicos — presença das macros e configurações certas (ex.:
log_e/log_w/log_i/log_d/log_v,CORE_DEBUG_LEVELno valor pedido, formataçãoprintf, etc.).
A nota de cada tarefa é proporcional ao número de verificações que passam.
A rubrica completa (tarefas, pontos e checagens) está em
.github/autograde/grade.py — o professor pode ajustá-la.
Parte 1 — Projeto PlatformIO
Na raiz do repositório, como no Lab 02. O --sample-code cria um src/main.cpp de exemplo, para o
projeto já compilar no commit da T1:
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --sample-code
Depois, fixe a plataforma no platformio.ini, como no Lab 02: platform = espressif32@6.9.0.
Projeto PlatformIO
git conferir platformio.ini src/main.cpp
git add platformio.ini src/main.cpp && git commit -m "T1: Projeto PlatformIO" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T1.
Parte 2 — ESP32 Arduino HAL Logging
Aqui está um exemplo completo para o arquivo src/main.cpp.
Este código demonstra a diferença entre as macros nativas do ESP32 Arduino Hal Logging (log_i, log_w, log_e, etc.) e o método tradicional Serial.println(), além de realizar o piscar de LED (blink) assíncrono utilizando millis().
Código: src/main.cpp
#include <Arduino.h>
// Definição do pino do LED (GPIO 2 é o LED embutido na maioria das placas ESP32 DevKit)
#define LED_PIN 2
// Intervalo de tempo para o Blink (em milissegundos)
const unsigned long BLINK_INTERVAL = 500;
// Variáveis de controle de tempo
unsigned long previousMillis = 0;
bool ledState = LOW;
uint32_t counter = 0;
void setup() {
// Configura o pino do LED como saída
pinMode(LED_PIN, OUTPUT);
// Inicializa a comunicação serial a 115200 baud
Serial.begin(115200);
// Aguarda um instante para a estabilização da conexão Serial
delay(1000);
Serial.println("\n==============================================");
Serial.println(" ESP32 Lab: Teste de Logs e Blink de LED ");
Serial.println("==============================================\n");
// Mensagens de Log do ESP32 (requer CORE_DEBUG_LEVEL > 0 no platformio.ini)
log_v("Log de Verbose: Informação detalhada/baixa relevância.");
log_d("Log de Debug: Informação para depuração do sistema.");
log_i("Log de Info: Sistema inicializado com sucesso no pino GPIO %d.", LED_PIN);
log_w("Log de Warning: Este é um exemplo de aviso!");
log_e("Log de Error: Este é um exemplo de erro simulação!");
}
void loop() {
unsigned long currentMillis = millis();
// Lógica de tempo não-bloqueante (evita o uso de delay)
if (currentMillis - previousMillis >= BLINK_INTERVAL) {
previousMillis = currentMillis;
// Inverte o estado do LED
ledState = !ledState;
digitalWrite(LED_PIN, ledState);
counter++;
// Mensagem via Serial.println padrão do Arduino
Serial.print("[Arduino Serial] Ciclo do LED: ");
Serial.print(counter);
Serial.print(" | Estado atual: ");
Serial.println(ledState ? "LIGADO" : "DESLIGADO");
// Mensagem usando o Log nativo do ESP32 a cada 5 trocas de estado
if (counter % 5 == 0) {
log_i("Contador atingiu %u trocas de estado.", counter);
}
}
}
Logs e pisca do LED
git conferir src/main.cpp
git add src/main.cpp && git commit -m "T2: Logs e pisca do LED" && 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.
Destaques do Código
log_i(),log_w(),log_e():
- São macros de log nativas do core ESP32/Arduino.
- Suportam formatação similar ao
printf(ex:%d,%s,%u). - Adicionam automaticamente a tag do arquivo, linha da chamada e cor (se a flag
-D CONFIG_ARDUHAL_LOG_COLORS=1estiver noplatformio.ini).
- Uso de
millis()em vez dedelay():
- O uso de
delay()bloqueia o processamento do ESP32. Utilizar a verificação pormillis()permite que o microcontrolador execute outras tarefas de segundo plano noloop()sem travar a CPU.
#include <Arduino.h>
void setup() {
Serial.begin(115200);
delay(1000);
#ifdef DEBUG_MODE
log_i("SISTEMA INICIADO EM MODO DE DEBUG");
log_d("Informações detalhadas de hardware e memória ativas.");
#else
// Código executado apenas no ambiente Release
Serial.println("Sistema iniciado (Modo Release).");
#endif
}
void loop() {
// Lógica do programa
}
Parte 3 — Logging no ESP32
Fundamentos: por que usar log em vez de Serial.print()?
Muita gente depura o ESP32 assim:
Serial.print("valor = ");
Serial.println(valor);
Funciona, mas tem problemas quando o projeto cresce:
- Não tem níveis. Um erro grave e uma mensagem de curiosidade têm a mesma aparência.
- Fica no binário para sempre. Você precisa comentar/apagar os
printna versão final, e isso é fácil de esquecer. - Não diz de onde veio. Em um projeto com 20 arquivos, "valor = 5" não ajuda a localizar a origem.
O sistema de log do Arduino-ESP32 resolve isso. Ele oferece cinco níveis de severidade e cada mensagem sai automaticamente com timestamp, nível, arquivo, linha e função de origem.
Os cinco níveis (do mais grave ao mais verboso)
| Macro | Nível | Valor | Quando usar |
|---|---|---|---|
log_e() | Error | 1 | Falhas que impedem a operação (sensor não responde). |
log_w() | Warning | 2 | Algo estranho, mas o programa continua (valor fora da faixa). |
log_i() | Info | 3 | Marcos normais de funcionamento ("WiFi conectado"). |
log_d() | Debug | 4 | Detalhes úteis durante o desenvolvimento. |
log_v() | Verbose | 5 | Tudo, inclusive laços internos e valores brutos. |
O valor 0 (NONE) desliga todos os logs.
A ideia-chave: o nível é decidido na compilação
Existe uma macro chamada CORE_DEBUG_LEVEL. Cada macro de log só gera código se o seu nível for menor ou igual a CORE_DEBUG_LEVEL. Ou seja:
- Se você compilar com
CORE_DEBUG_LEVEL=3(Info), entãolog_d()elog_v()desaparecem do binário — não ocupam memória nem gastam tempo de CPU. - Para gerar a versão "de produção", basta recompilar com
CORE_DEBUG_LEVEL=1(só erros) ou0(nenhum log). Você não apaga uma linha sequer do código.
As mensagens de debug ficam no código-fonte, documentando o programa, mas somem do produto final com uma única troca de configuração.
A API do esp32-hal-log.h
Formatação estilo printf
As macros aceitam os mesmos especificadores do printf do C:
int temp = 25;
float tensao = 3.31;
const char* estado = "OK";
log_i("Temperatura: %d C", temp);
log_i("Tensao: %.2f V", tensao);
log_i("Estado do sensor: %s", estado);
log_d("temp=%d tensao=%.2f estado=%s", temp, tensao, estado);
Principais especificadores: %d (inteiro), %u (inteiro sem sinal), %.2f (float com 2 casas), %s (string C), %c (caractere), %x (hexadecimal), %p (ponteiro), %% (o próprio símbolo de porcentagem).
Formato da saída no monitor serial
Uma chamada como log_i("Sistema iniciado") dentro de setup() produz algo assim:
[342][I][main.cpp:15] setup(): Sistema iniciado
Lendo da esquerda para a direita:
[342]— timestamp em milissegundos desde o boot.[I]— o nível (E, W, I, D ou V).[main.cpp:15]— arquivo e linha exatos de onde a mensagem saiu.setup():— a função que a chamou.Sistema iniciado— a sua mensagem.
Você não precisa escrever nada disso: o prefixo é montado automaticamente pela macro.
Dump de memória em hexadecimal
Para inspecionar buffers (ex.: pacotes de rede, leitura de sensor I2C), existem as variantes log_buf_*:
uint8_t pacote[] = {0xDE, 0xAD, 0xBE, 0xEF, 0x01, 0x02};
log_buf_i(pacote, sizeof(pacote));
Isso imprime os bytes formatados em hexadecimal, útil para depurar protocolos.
Configurar o platformio.ini
Este é o passo mais importante da aula. Abra o platformio.ini na raiz do projeto e deixe-o assim:
[env:esp32dev]
platform = espressif32@6.9.0 ; versão fixa (Lab 02)
board = esp32dev
framework = arduino
monitor_speed = 115200
; CORE_DEBUG_LEVEL define ate que nivel de log sera COMPILADO:
; 0 = NONE | 1 = ERROR | 2 = WARN | 3 = INFO | 4 = DEBUG | 5 = VERBOSE
build_flags =
-DCORE_DEBUG_LEVEL=5
| Macro | CORE_DEBUG_LEVEL ≥ | Uso típico |
|---|---|---|
log_e("...", ...) | 1 | Erro |
log_w("...", ...) | 2 | Aviso |
log_i("...", ...) | 3 | Informação |
log_d("...", ...) | 4 | Debug |
log_v("...", ...) | 5 | Verbose |
log_buf_i(buf, tam) | 3 | Dump hexadecimal |
Em platformio.ini: build_flags = -DCORE_DEBUG_LEVEL=<0..5>
Se você esquecer o -DCORE_DEBUG_LEVEL, o valor padrão costuma ser 0 (NONE) e nada aparece, mesmo com o código correto. Se seus logs sumiram, comece a investigação por aqui.
Para conhecer: ambientes de debug e de release (não é usado nas tarefas)
Um mesmo projeto pode ter vários ambientes. Este exemplo tem um de desenvolvimento, com logs, e um
de produção, sem logs. O de desenvolvimento se chama esp32dev para o wokwi.toml continuar
achando o firmware em .pio/build/esp32dev/; o de produção compila em .pio/build/release/.
[platformio]
; ambiente padrão quando nenhum é pedido (pio run -e release compila o outro)
default_envs = esp32dev
; =====================================================================
; Configurações comuns (herdadas por todos os ambientes)
; =====================================================================
[env]
platform = espressif32@6.9.0
board = esp32dev
framework = arduino
monitor_speed = 115200
; =====================================================================
; Desenvolvimento (debug)
; =====================================================================
[env:esp32dev]
build_type = debug
monitor_filters =
esp32_exception_decoder
colorize
time
build_flags =
-D CORE_DEBUG_LEVEL=4 ; 4 = Debug, 5 = Verbose
-D CONFIG_ARDUHAL_LOG_COLORS=1 ; cores no console
-D DEBUG_MODE ; macro própria (#ifdef DEBUG_MODE)
; =====================================================================
; Produção (release)
; =====================================================================
[env:release]
build_type = release
upload_speed = 921600
build_flags =
-D CORE_DEBUG_LEVEL=0 ; 0 = logs desligados (economiza flash e RAM)
-Os ; otimiza o tamanho do binário
O código-base (src/main.cpp)
#include <Arduino.h>
void setup() {
Serial.begin(115200);
delay(1000); // da tempo do monitor serial abrir e nao perder as 1as linhas
log_i("===== Laboratorio de Log ESP32 =====");
log_i("Sistema iniciado com sucesso");
}
void loop() {
// veremos o loop nos exercicios
}
Observe que usamos Serial.begin() normalmente. O sistema de log escreve no mesmo periférico serial; o Serial.begin continua sendo o que inicializa a UART e define a velocidade.
CORE_DEBUG_LEVEL no platformio.ini
git conferir platformio.ini
git add platformio.ini && git commit -m "T3: CORE_DEBUG_LEVEL no platformio.ini" && 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.
Configurando o Wokwi
O Wokwi simula o ESP32 usando o firmware já compilado pelo PlatformIO. Precisamos de dois arquivos na raiz do projeto.
- diagram.json
- wokwi.toml
O "circuito": a placa e o LED no GPIO2, com resistor de 220 Ω (o mesmo circuito do Lab 02):
{
"version": 1,
"author": "elt73a - 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": {}
}
As duas primeiras conexões ligam a UART do ESP32 ao monitor serial do simulador: é o que faz os logs aparecerem na tela do Wokwi.
Aponta para o firmware compilado:
[wokwi]
version = 1
firmware = '.pio/build/esp32dev/firmware.bin'
elf = '.pio/build/esp32dev/firmware.elf'
Se o seu ambiente no platformio.ini não se chamar esp32dev, ajuste o caminho .pio/build/<nome-do-env>/ de acordo.
Wokwi no VS Code
git conferir diagram.json wokwi.toml
git add diagram.json wokwi.toml && git commit -m "T4: 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 T4.
O fluxo de trabalho
- Compile: ícone do PlatformIO na barra inferior (✓ "Build"), ou
Ctrl+Alt+B. Isso gera ofirmware.bin/.elf. - Simule: abra a paleta de comandos (
Ctrl+Shift+P) → Wokwi: Start Simulator. - Uma aba com a placa e o monitor serial do Wokwi aparece. Seus logs surgem ali.
O Wokwi só roda o que já foi compilado. Se você mudar o código, compile de novo antes de reiniciar o simulador, senão vai ver o firmware antigo.
Roteiro de laboratório (prática guiada)
Exercício 1 — Os cinco níveis de uma vez
Substitua o setup() por:
void setup() {
Serial.begin(115200);
delay(1000);
log_e("Isto e um ERRO (log_e)");
log_w("Isto e um AVISO (log_w)");
log_i("Isto e uma INFO (log_i)");
log_d("Isto e DEBUG (log_d)");
log_v("Isto e VERBOSE (log_v)");
}
Compile com CORE_DEBUG_LEVEL=5 e simule. Anote: você deve ver as cinco linhas, cada uma com seu prefixo de nível.
Exercício 2 — Filtrando por nível de compilação
Sem mudar o código do Exercício 1, edite o platformio.ini e troque para:
build_flags =
-DCORE_DEBUG_LEVEL=2
Compile de novo e simule. Observe: agora só aparecem log_e e log_w. As linhas de Info, Debug e Verbose foram removidas do binário na compilação — não é um filtro em tempo de execução, elas literalmente não existem mais no firmware.
Por que isso é melhor do que um if (nivel <= X) dentro do código?
Exercício 3 — Log com dados formatados
Volte para CORE_DEBUG_LEVEL=5 e use um loop() que simula a leitura de um sensor:
void loop() {
static int contador = 0;
float temperatura = 20.0 + (contador % 15); // valor fake que varia
log_d("Ciclo #%d iniciado", contador);
log_i("Leitura de temperatura: %.1f C", temperatura);
if (temperatura > 30.0) {
log_w("Temperatura alta: %.1f C (limite 30)", temperatura);
}
contador++;
delay(1000);
}
Simule e acompanhe o timestamp crescendo de ~1000 ms em ~1000 ms, e o aviso aparecendo só quando o valor passa de 30.
Exercício 4 — Simulando um erro real
Vamos fingir que um sensor falhou:
bool lerSensor(float* saida) {
static int tentativa = 0;
tentativa++;
if (tentativa % 4 == 0) { // a cada 4 leituras, "falha"
log_e("Falha ao ler sensor na tentativa %d", tentativa);
return false;
}
*saida = 25.5;
log_v("Sensor respondeu OK na tentativa %d", tentativa);
return true;
}
void loop() {
float t;
if (lerSensor(&t)) {
log_i("Temperatura valida: %.1f C", t);
} else {
log_w("Usando ultimo valor conhecido (leitura ignorada)");
}
delay(1000);
}
Objetivo pedagógico: perceber como os níveis contam uma história — o log_e marca a falha exata (com número da tentativa e linha do arquivo), o log_w mostra a recuperação, e o log_v só aparece se você quiser o detalhe fino.
Exercícios propostos (para entregar)
Cada exercício é uma tarefa, entregue no seu commit Tn:.
T5 — Contador de erros
Modifique o Exercício 4 para contar quantas falhas ocorreram e, a cada 10 ciclos, emitir um log_i
com a taxa de falhas em porcentagem (%.1f%%).
Contador de erros
git conferir src/main.cpp
git add src/main.cpp && git commit -m "T5: Contador de erros" && 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.
T6 — Nível de produção
Compile o projeto com CORE_DEBUG_LEVEL=1 e descreva no README.md o que muda na saída. Explique
por que essa seria a configuração para um produto entregue ao cliente. Faça o commit com o nível
1; na T7, volte para 5.
Nivel de producao
git conferir platformio.ini README.md
git add platformio.ini README.md && git commit -m "T6: Nivel de producao" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T6.
T7 — Hexdump
Volte para CORE_DEBUG_LEVEL=5. Crie um uint8_t buffer[8] preenchido com valores à sua escolha e
imprima-o com log_buf_i(). Cole a saída no README.md.
Hexdump
git conferir platformio.ini src/main.cpp README.md
git add platformio.ini src/main.cpp README.md && git commit -m "T7: Hexdump" && 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 T7.
T8 — Desafio: pisca com log_d
O LED do diagrama já está no GPIO2 (T4). Junte ao código atual o pisca com millis() da T2, sem
delay(), e emita um log_d a cada troca de estado do LED.
Desafio: pisca com log_d
git conferir src/main.cpp diagram.json
git add src/main.cpp diagram.json && git commit -m "T8: Desafio: pisca com log_d" && 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 T8.
Referência rápida
| Macro | Aparece quando CORE_DEBUG_LEVEL ≥ | Uso típico |
|---|---|---|
log_e("...", ...) | 1 | Erro |
log_w("...", ...) | 2 | Aviso |
log_i("...", ...) | 3 | Informação |
log_d("...", ...) | 4 | Debug |
log_v("...", ...) | 5 | Verbose |
log_buf_i(buf, tam) | 3 | Dump hexadecimal |
Em platformio.ini: build_flags = -DCORE_DEBUG_LEVEL=<0..5>
Solução de problemas (troubleshooting)
| Sintoma | Causa provável | Solução |
|---|---|---|
| Nenhum log aparece | CORE_DEBUG_LEVEL não definido ou 0 | Adicione -DCORE_DEBUG_LEVEL=5 em build_flags e recompile |
| Só aparecem erros e avisos | Nível de compilação baixo (1 ou 2) | Suba o CORE_DEBUG_LEVEL |
| Caracteres estranhos | Velocidade errada | monitor_speed deve bater com Serial.begin() (115200) |
| As primeiras linhas somem | Monitor abriu depois do boot | Adicione delay(1000) após Serial.begin() |
| Wokwi mostra código antigo | Simulou sem recompilar | Faça Build antes de Start Simulator |
| Wokwi não acha o firmware | Caminho errado no wokwi.toml | Confira o nome do env em .pio/build/<env>/ |
log_i "não existe" | Faltou #include <Arduino.h> | O header de log já vem junto do core Arduino; garanta o include |
Documentação de Referência da Linguagem Arduino
- https://docs.arduino.cc/language-reference/pt/
- arduino-esp32
- Espressif 32
- platform-espressif32
- platformio/espressif32
Sketch - setup()
A função setup() é chamada quando um sketch inicia. Use-a para inicializar variáveis, configurar o modo dos pinos(INPUT ou OUTPUT), inicializar bibliotecas, etc. A função setup() será executada apenas uma vez, apoós a placa ser alimentada ou acontecer um reset.
int buttonPin = 3;
void setup() {
// Inicializa a porta serial
Serial.begin(9600);
// configura o pino 3 como INPUT
pinMode(buttonPin, INPUT);
}
void loop() {
// ...
}
Sketch - loop()
Depois de criar uma função setup(), a qual inicializa e atribui os valores iniciais, a função loop() faz precisamente o que o seu nome sugere, e repete-se consecutivamente enquanto a placa estiver ligada, permitindo o seu programa mudar e responder a essas mudanças. Use-a para controlar ativamente uma placa Arduino.
int buttonPin = 3;
// setup inicializa a porta serial e o pino para o botão
void setup() {
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}
// loop checa o estado do botão repetidamente, e envia
// pela serial um 'H' se este está sendo pressionado
void loop() {
if (digitalRead(buttonPin) == HIGH) {
Serial.write('H');
}
else {
Serial.write('L');
}
delay(1000);
}
Bits, Bytes e Operadores no ESP32
Estruturas de Controle no ESP32
Parte 4 — CI no GitHub Actions
Um workflow que compila o firmware a cada push. Se o código parar de compilar, a execução fica
vermelha na aba Actions.
- ├── 📂.github
- └── 📂workflows
- └── 🚀ci.yml👈 Criar Aqui
- └── 📂workflows
- ├── 📄...
- └── 📂src
- └── 📄main.cpp
git conferir .github/workflows/ci.yml
name: CI
on: [push, pull_request]
env:
PLATFORMIO_VERSAO: "6.2.0" # versão fixa, como a plataforma no platformio.ini
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: actions/setup-python@v7
with:
python-version: "3.12"
- name: Cache do PlatformIO
uses: actions/cache@v6
with:
path: |
~/.platformio
~/.cache/pip
key: pio-${{ runner.os }}-${{ env.PLATFORMIO_VERSAO }}-${{ hashFiles('platformio.ini') }}
- name: Instala o PlatformIO
run: pip install "platformio==${PLATFORMIO_VERSAO}"
- name: Compila o firmware
run: pio run
ci.yml?O nome ci.yml é o mesmo do Lab 10 e não se confunde com o workflow do autograder que vem no
template do repositório. Não apague nem renomeie os arquivos que já estão em .github/.
CI no GitHub Actions
git conferir .github/workflows/ci.yml
git add .github/workflows/ci.yml && git commit -m "T9: CI no GitHub Actions" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T9.
Os testes automáticos do firmware no simulador (wokwi-cli com --expect-text, cenários e
analisador lógico) entram no pipeline no Lab 10. Referências:
Wokwi CI ·
Uso do Wokwi CLI ·
Migrar projetos do Wokwi para o VS Code
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.